# SYNAPSE दस्तावेज़ — संपूर्ण संदर्भ
# जनरेट किया गया: 2026-07-18T04:13:20.229Z
# कुल लेख: 47

इस दस्तावेज़ में संपूर्ण Synapse API दस्तावेज़ शामिल है।
Base URL: https://synapse.schaefer.zone
Language: hi

========================================================================

## श्रेणी: शुरू करें
Synapse के साथ शुरुआत करने के लिए सब कुछ।

────────────────────────────────────────────────────────────
# प्रमाणीकरण और Mind Keys
SUMMARY: Synapse प्रमाणीकरण कैसे काम करता है: एजेंट्स के लिए Mind Keys, मानवों के लिए JWTs, URL-केवल टूल्स के लिए ?key=।

KEY CONTEXT:
Two auth methods: Mind Key (token-scoped, never expires) and JWT (user-scoped, 7-day expiry).
Mind Key: Authorization: Bearer mk_xxx OR ?key=mk_xxx (60 req/min limit on query)
JWT: Authorization: Bearer eyJ... (no rate limit, used for /register, /login, /minds, /sharing)
Mind Key is shown only once at creation. Store it permanently.
Each mind has exactly one Mind Key. Multiple minds = multiple keys.

प्रमाणीकरण और Mind Keys
Synapse दो प्रमाणीकरण विधियों का उपयोग करता है, प्रत्येक अलग उपयोग के मामले के लिए अनुकूलित। विश्वसनीय इंटीग्रेशन बनाने के लिए अंतर को समझना आवश्यक है।
दो प्रमाणीकरण विधियाँ
| विधि | उपयोग का मामला | रेट लिमिट | समाप्ति |
|--------|----------|------------|--------|
| Mind Key | LLM एजेंट्स, स्वचालित टूल्स | कोई नहीं (हेडर) / 60 मिनट (क्वेरी) | कभी नहीं |
| JWT | मानव-सामने UI, खाता ऑप्स | कोई नहीं | 7 दिन |
Mind Key (एजेंट्स के लिए)
Mind Key एक टैनेंट-स्कोप्ड API टोकन है। यह एकल mind के डेटा (मेमोरीज़, कार्य, चैट, स्क्रिप्ट्स, आदि) को प्रमाणित करता है। इसका उपयोग करें:
- API कॉल करने वाले LLM एजेंट्स
- बैकग्राउंड ऑटोमेशन स्क्रिप्ट्स
- MCP server कॉन्फ़िगरेशन
- कोई भी दीर्घ-जीवित इंटीग्रेशन
हेडर प्रमाणीकरण (अनुशंसित)
[CODE BLOCK]
क्वेरी पैरामीटर (URL-केवल टूल्स के लिए)
[CODE BLOCK]
> [!WARNING]
>  क्वेरी पैरामीटर 60 requests per minute तक सीमित है।
> Bearer हेडर की कोई रेट लिमिट नहीं है। जब भी आपका क्लाइंट कस्टम हेडर का समर्थन करता है हेडर का उपयोग करें।
Mind Key बनाना
[CODE BLOCK]
प्रतिक्रिया में  शामिल है — इसे तुरंत सहेजें, यह केवल एक बार दिखाई जाती है।
अपने minds की सूची बनाना
[CODE BLOCK]
Mind हटाना (अपरिवर्तनीय!)
[CODE BLOCK]
JWT (मानवों के लिए)
JWT विशिष्ट mind नहीं, बल्कि उपयोगकर्ता खाते को प्रमाणित करते हैं। इनका उपयोग करें:
- खाता पंजीकरण और लॉगिन
- Minds बनाने / सूचीबद्ध करने / हटाने
- अन्य उपयोगकर्ताओं के साथ minds साझा करने
- Web Push सब्सक्रिप्शन प्रबंधन
पंजीकरण
[CODE BLOCK]
लौटाता है: 
लॉगिन
[CODE BLOCK]
लौटाता है: 
JWT समाप्ति
JWT 7 दिनों के बाद समाप्त होते हैं। JWT समाप्त होने पर, नया प्राप्त करने के लिए बस  फिर से कॉल करें। Mind Key कभी समाप्त नहीं होती, इसलिए मौजूदा एजेंट इंटीग्रेशन काम करते रहते हैं।
सुरक्षा सर्वोत्तम प्रथाएँ
> [!CRITICAL]
> - Mind Keys कभी git में कमिट न करें। पर्यावरण वेरिएबल्स का उपयोग करें।
> - Mind Keys कभी लॉग न करें। लॉग में उन्हें मास्क करें ()।
> - लीक के संदेह होने पर keys रोटेट करें (mind हटाएँ, नया बनाएँ)।
> - प्रति परियोजना एक mind का उपयोग करें ताकि लीक होने पर प्रभाव सीमित रहे।
पर्यावरण वेरिएबल पैटर्न
[CODE BLOCK]
[CODE BLOCK]
MCP server config
[CODE BLOCK]
मल्टी-Mind पैटर्न
प्रत्येक उपयोगकर्ता के पास कई minds हो सकते हैं। सामान्य पैटर्न:
| Mind नाम | उद्देश्य |
|-----------|---------|
|  | कार्य-संबंधी मेमोरीज़ |
|  | व्यक्तिगत प्राथमिकताएँ, परिवार |
|  | विशिष्ट परियोजना संदर्भ |
|  | सीखने की प्रगति |
|  | सामान्य-उद्देश्य fallback |
संदर्भ अलग रखने के लिए विभिन्न LLM सत्रों के लिए विभिन्न Mind Keys का उपयोग करें।
रेट लिमिट
| प्रमाणीकरण विधि | सीमा | दायरा |
|-------------|-------|-------|
| Mind Key (हेडर) | कोई नहीं | प्रति-mind |
| Mind Key (?key=) | 60/min | प्रति-IP |
| JWT (हेडर) | कोई नहीं | प्रति-उपयोगकर्ता |
| सार्वजनिक एंडपॉइंट्स | कोई नहीं | वैश्विक |
रेट लिमिट हेडर (, , ) जब लागू हो तब प्रतिक्रियाओं में शामिल होते हैं।
अगले कदम
- Mind Key vs JWT — कब क्या उपयोग करें
- Memory API — Mind Key से आप क्या कर सकते हैं
- User API — JWTs के साथ खाता प्रबंधन

────────────────────────────────────────────────────────────
# Mind Key बनाम JWT — क्या कब?
SUMMARY: निर्णय गाइड: एजेंट डेटा एक्सेस के लिए Mind Key, खाता प्रबंधन के लिए JWT।

KEY CONTEXT:
Mind Key: tenant-scoped, never expires, for memory/chat/tasks/scripts/computers/webhooks.
JWT: user-scoped, 7-day expiry, for /register, /login, /minds (CRUD), /sharing, /push.
Simple rule: if it touches a single mind's data → Mind Key. If it manages the account → JWT.
Exception: /computers/me/* uses Computer Token (not Mind Key or JWT).

Mind Key बनाम JWT — क्या कब?
Synapse में दो प्रमाणीकरण टोकन हैं। गलत चुनने से 401 त्रुटियाँ होती हैं। यह गाइड आपको स्पष्ट निर्णय ढाँचा देता है।
त्वरित निर्णय तालिका
| आप क्या चाहते हैं... | उपयोग करें |
|----------------|-----|
| मेमोरीज़ स्टोर / रिकॉल | Mind Key |
| चैट संदेश भेजें / poll | Mind Key |
| कार्य प्रबंधित करें | Mind Key |
| स्क्रिप्ट्स स्टोर करें | Mind Key |
| Webhooks पंजीकृत करें | Mind Key |
| कंप्यूटर्स नियंत्रित करें | Mind Key (उपयोगकर्ता-साइड) / Computer Token (एजेंट-साइड) |
| उपयोगकर्ता खाता पंजीकृत करें | कोई नहीं (सार्वजनिक) |
| लॉगिन | कोई नहीं (सार्वजनिक) |
| Minds बनाएँ / सूचीबद्ध करें / हटाएँ | JWT |
| अन्य उपयोगकर्ता के साथ mind साझा करें | JWT |
| Web push सूचनाओं की सदस्यता लें | JWT |
| ऑडिट लॉग देखें | Mind Key |
सरल नियम
> [!TIP]
> यदि यह एकल mind के डेटा को छूता है → Mind Key।
> यदि यह खाता या mind मेटाडेटा प्रबंधित करता है → JWT।
Mind Key — डेटा एक्सेस टोकन
Mind Key एक mind के डेटा तक पहुँच प्रदान करती है। यह एक दीर्घ-जीवित टोकन है जो कभी समाप्त नहीं होता (जब तक mind हटाया न जाए)। इनके लिए आदर्श:
- सत्रों में मेमोरीज़ बनाए रखने वाले LLM एजेंट्स
- बैकग्राउंड cron कार्य
- MCP server कॉन्फ़िगरेशन
- Webhook इंटीग्रेशन
- मेमोरी पढ़ने वाले मोबाइल ऐप्स
Mind Key क्या कर सकती है
-  — इस mind में सभी मेमोरीज़ पढ़ें
-  — मेमोरीज़ स्टोर/अपडेट करें
-  — चैट संदेश पढ़ें
-  — चैट संदेश भेजें
-  — कार्य सूचीबद्ध करें
-  — कार्य बनाएँ
-  — स्क्रिप्ट्स स्टोर करें
-  — webhooks पंजीकृत करें
-  — कंप्यूटर कमांड्स कतारबद्ध करें
Mind Key क्या नहीं कर सकती
- Minds बनाना / सूचीबद्ध करना / हटाना (JWT चाहिए)
- अन्य उपयोगकर्ता के साथ mind साझा करना (JWT चाहिए)
- उपयोगकर्ता खाता जानकारी देखना (JWT चाहिए)
- Web push की सदस्यता लेना (JWT चाहिए)
JWT — खाता प्रबंधन टोकन
JWT उपयोगकर्ता खाते को प्रमाणित करता है। यह 7 दिनों के बाद समाप्त होता है और खाता-स्तरीय ऑपरेशन्स के लिए उपयोग किया जाता है जो कई minds तक फैले या अन्य उपयोगकर्ताओं को शामिल करें।
JWT क्या कर सकता है
-  — नया mind बनाएँ (नई Mind Key लौटाता है)
-  — इस उपयोगकर्ता के सभी minds सूचीबद्ध करें
-  — mind हटाएँ
-  — अन्य उपयोगकर्ता के साथ mind साझा करें
-  — web push सूचनाओं की सदस्यता लें
-  — mind shares सूचीबद्ध करें
JWT क्या नहीं कर सकता
- मेमोरीज़ पढ़ना / लिखना (Mind Key चाहिए)
- चैट संदेश भेजना (Mind Key चाहिए)
- कार्य प्रबंधित करना (Mind Key चाहिए)
- Webhooks पंजीकृत करना (Mind Key चाहिए)
विशेष मामला: Computer Token
 एंडपॉइंट्स (एजेंट-सामने, screen-remote-agent के लिए) तीसरे टोकन प्रकार का उपयोग करते हैं: Computer Token। यह टोकन इंस्टॉल कोड रिडीम करते समय  द्वारा लौटाया जाता है, और एक पंजीकृत कंप्यूटर के लिए विशिष्ट है।
| एंडपॉइंट | प्रमाणीकरण |
|----------|------|
|  | Computer Token |
|  | Computer Token |
|  | Mind Key या JWT |
|  | Mind Key या JWT |
सामान्य पैटर्न
पैटर्न 1: एकल LLM एजेंट
1. एक बार पंजीकरण करें → JWT प्राप्त करें
2. एक mind बनाएँ → Mind Key प्राप्त करें
3. LLM सब कुछ के लिए Mind Key का उपयोग करता है
पैटर्न 2: मल्टी-परियोजना एजेंट
1. एक बार पंजीकरण करें → JWT प्राप्त करें
2. कई minds बनाएँ (work, personal, project-x) → कई Mind Keys प्राप्त करें
3. LLM संदर्भ के आधार पर भिन्न Mind Key लोड करता है
पैटर्न 3: टीम साझाकरण
1. उपयोगकर्ता A एक mind बनाता है → Mind Key A प्राप्त करता है
2. उपयोगकर्ता A JWT के माध्यम से उपयोगकर्ता B के साथ साझा करता है ()
3. उपयोगकर्ता B अब अपने JWT के माध्यम से एक्सेस कर सकता है
4. LLM एक्सेस के लिए, उपयोगकर्ता B को अपनी Mind Key बनानी होगी (या A की उपयोग करें)
पैटर्न 4: MCP Server
MCP servers हमेशा Mind Key का उपयोग करते हैं ( env var के माध्यम से सेट)। एक MCP server इंस्टेंस = एक mind। मल्टी-mind एक्सेस के लिए, कई MCP इंस्टेंस चलाएँ या क्लाइंट-साइड mind-स्विचिंग लागू करें।
टोकन प्रारूप चीट शीट
| टोकन | प्रारूप | उदाहरण |
|-------|--------|---------|
| Mind Key |  + 36 chars |  |
| JWT |  + base64 |  |
| Computer Token |  + 36 chars |  |
अगले कदम
- प्रमाणीकरण — पूर्ण प्रमाणीकरण गाइड
- User और Minds API — JWT-सुरक्षित एंडपॉइंट्स
- Memory API — Mind Key-सुरक्षित एंडपॉइंट्स

────────────────────────────────────────────────────────────
# LLM एजेंट्स के लिए Quick Start
SUMMARY: 3 API कॉल्स में: सभी मेमोरीज़ रिकॉल करें, नई स्टोर करें, खोजें। आवश्यक LLM वर्कफ़्लो।

KEY CONTEXT:
Base URL: https://synapse.schaefer.zone
Auth: Authorization: Bearer YOUR_MIND_KEY (header) OR ?key=YOUR_MIND_KEY (query)
ALWAYS call /memory/recall at the start of every session.
Wichtigste Befehle: GET /memory/recall, POST /memory, GET /memory/search?q=...
Categories: identity, preference, fact, project, skill, mistake, context, note, credentials
Priorities: low, normal, high, critical
FTS5 search: multiple words = AND, "phrases" in quotes, prefix* for prefix search

LLM एजेंट्स के लिए Quick Start
आप सत्रों के बीच सभी मेमोरी खो देते हैं। Synapse आपका बाहरी मस्तिष्क है। यह गाइड तीन आवश्यक API कॉल्स दिखाती है जो हर LLM एजेंट को जानना चाहिए।
> [!CRITICAL]
> हर सत्र की शुरुआत में  कॉल करें।
> इस कॉल के बिना, आपको यह याद नहीं कि उपयोगकर्ता कौन है, आपने क्या वादा किया, या पिछली बार आप किस पर काम कर रहे थे।
चरण 1: सभी मेमोरीज़ रिकॉल करें (हमेशा पहले)
[CODE BLOCK]
सभी स्टोर की गई मेमोरीज़ का संरचित सादा-टेक्स्ट सारांश लौटाता है। उपयोगकर्ता, उनकी परियोजनाओं, और पिछले इंटरैक्शन्स का मानसिक मॉडल पुनर्निर्माण के लिए इसे पार्स करें।
उदाहरण प्रतिक्रिया:
[CODE BLOCK]
चरण 2: नई मेमोरी स्टोर करें
जब आप कुछ याद रखने लायक सीखें:
[CODE BLOCK]
श्रेणियाँ: , , , , , , , , 
प्राथमिकताएँ: , , , 
> [!TIP]
> हमेशा  फ़ील्ड शामिल करें — मेमोरी के लिए एक छोटा पहचानकर्ता। यह आपको समान कुंजी के साथ फिर से POST करके उसी मेमोरी को बाद में अपडेट करने देता है।
चरण 3: विशिष्ट मेमोरी खोजें
[CODE BLOCK]
> [!TIP]
> FTS5 सिंटैक्स: कई शब्द = AND खोज। उद्धरण में वाक्यांश: ।
> उपसर्ग खोज: । बूलियन: ।
खुले टूल्स (कोई Auth हेडर नहीं)
यदि आपका टूल केवल URLs खोल सकता है (कोई कस्टम हेडर नहीं), तो  पैरामीटर का उपयोग करें:
[CODE BLOCK]
> [!WARNING]
>  60 requests/minute तक सीमित है। Bearer हेडर की कोई रेट लिमिट नहीं है।
> जब संभव हो Bearer हेडर का उपयोग करें।
संपूर्ण सत्र वर्कफ़्लो
1. सत्र शुरुआत:  — सभी मेमोरीज़ लोड करें
2. काम के दौरान:  — विशिष्ट तथ्य खोजें
3. नई जानकारी पर:  — इसे स्टोर करें (category, key, tags, priority के साथ)
4. समय-समय पर:  — मानव संदेशों के लिए जाँचें
5. सत्र अंत: किसी भी अंतिम सीखने को  से स्टोर करें
सामान्य पैटर्न
मौजूदा मेमोरी अपडेट करें
समान  और  के साथ POST  — मौजूदा मेमोरी अपडेट होती है, डुप्लिकेट नहीं होती।
परियोजना स्थिति स्टोर करें
[CODE BLOCK]
गलती रिकॉर्ड करें (ताकि आप दोहराएं नहीं)
[CODE BLOCK]
मानव संदेशों के लिए जाँचें
[CODE BLOCK]
मानव से अपठित संदेश लौटाता है। इससे उत्तर दें:
[CODE BLOCK]
अगले कदम
- प्रमाणीकरण — Mind Key vs JWT
- Memory API संदर्भ — सभी 22 मेमोरी एंडपॉइंट्स
- Chat API — मानवों के साथ अतुल्यकालिक संचार
- LLM Cookbook — व्यावहारिक पैटर्न

────────────────────────────────────────────────────────────
# Quick Start (मानव)
SUMMARY: खाता पंजीकृत करें, अपना पहला mind बनाएँ, मेमोरी स्टोर करें — सब 5 मिनट में।

Quick Start (मानव)
यह गाइड आपको Synapse खाता प्राप्त करने, अपनी पहली Mind Key, और अपनी पहली मेमोरी स्टोर करने में मार्गदर्शन करती है। कुल समय: 5 मिनट।
चरण 1: खाता पंजीकृत करें
Synapse API खोलें और एक खाता बनाएँ:
[CODE BLOCK]
प्रतिक्रिया:
[CODE BLOCK]
> [!TIP]
> JWT को सुरक्षित जगह सहेजें — minds बनाने के लिए इसकी आवश्यकता होगी। JWT 7 दिनों के बाद समाप्त होता है; रिफ्रेश करने के लिए उसी एंडपॉइंट से फिर से लॉगिन करें।
चरण 2: अपना पहला Mind बनाएँ
"Mind" एक अलग मेमोरी दायरा है। अधिकांश उपयोगकर्ता एक mind से शुरू करते हैं, लेकिन आपके पास कई हो सकते हैं (जैसे "work", "personal", "project-x")। प्रत्येक mind की अपनी अद्वितीय Mind Key होती है।
[CODE BLOCK]
प्रतिक्रिया:
[CODE BLOCK]
> [!CRITICAL]
>  तुरंत सहेजें। यह केवल एक बार दिखाई जाती है और बाद में पुनः प्राप्त नहीं की जा सकती। यदि आप इसे खो देते हैं, तो आपको नया mind बनाना होगा।
चरण 3: अपनी पहली मेमोरी स्टोर करें
अब मेमोरी स्टोर करने के लिए Mind Key का उपयोग करें:
[CODE BLOCK]
प्रतिक्रिया:
[CODE BLOCK]
चरण 4: सभी मेमोरीज़ रिकॉल करें
आपने जो कुछ भी स्टोर किया है उसे पुनः प्राप्त करने के लिए:
[CODE BLOCK]
प्रतिक्रिया (सादा टेक्स्ट, LLM खपत के लिए अनुकूलित):
[CODE BLOCK]
चरण 5: मेमोरीज़ खोजें
कीवर्ड द्वारा विशिष्ट मेमोरीज़ खोजें:
[CODE BLOCK]
चरण 6: अपना LLM कनेक्ट करें
आपके LLM को Synapse एक्सेस देने का सबसे आसान तरीका MCP के माध्यम से है:
- Claude Desktop सेटअप — 2-मिनट config
- Claude Code सेटअप — terminal इंटीग्रेशन
- Cursor सेटअप — IDE इंटीग्रेशन
सेटअप के बाद, आपका LLM हर सत्र की शुरुआत में स्वचालित रूप से  कॉल करेगा और नए तथ्य  से बनाए रखेगा।
मेमोरी श्रेणियाँ
Synapse 8 श्रेणियों का समर्थन करता है — सबसे विशिष्ट चुनें:
| श्रेणी | उपयोग का मामला |
|----------|----------|
|  | उपयोगकर्ता नाम, भूमिका, संपर्क जानकारी |
|  | पसंद, नापसंद, कार्य शैली |
|  | सत्यापित योग्य तथ्य (परियोजना विवरण, तिथियाँ) |
|  | परियोजना स्थिति, मील के पत्थर, todos |
|  | चीज़ें जिनमें उपयोगकर्ता अच्छा है |
|  | पिछली त्रुटियाँ — दोहराने से बचें |
|  | सत्र-प्रासंगिक संदर्भ |
|  | विविध नोट्स |
प्राथमिकता स्तर
-  — जानना अच्छा है
-  — डिफ़ॉल्ट
-  — महत्वपूर्ण
-  — कभी न भूलें (उपयोगकर्ता पहचान, कानूनी जानकारी)
अगले कदम
- प्रमाणीकरण गहन
- Mind Key vs JWT
- Memory API संदर्भ
- MCP इंटीग्रेशन

────────────────────────────────────────────────────────────
# Synapse क्या है?
SUMMARY: Synapse LLM एजेंट्स के लिए एक स्थायी मेमोरी API है — आपका AI सत्रों के बीच कभी नहीं भूलता।

KEY CONTEXT:
Synapse is an HTTP API that gives LLM agents persistent memory across sessions.
Base URL: https://synapse.schaefer.zone
Auth: Authorization: Bearer YOUR_MIND_KEY (header) OR ?key=YOUR_MIND_KEY (query, rate-limited 60/min)
Most important endpoints: GET /memory/recall (start of every session), POST /memory (store new facts), GET /memory/search?q=...
Mind Key = tenant-scoped API key. Each user can have multiple minds (projects/contexts).
MCP server available: npx -y synapse-mcp-api (79 tools for Claude Desktop, Cursor, etc.)

Synapse क्या है?
Synapse LLM एजेंट्स के लिए स्थायी मेमोरी API है। यह हर चैट-आधारित LLM की मौलिक समस्या को हल करता है: सत्रों के बीच, एजेंट सब कुछ भूल जाता है। Synapse आपके AI को एक स्थायी, क्वेरी करने योग्य मस्तिष्क देता है जो बातचीत, दिनों, और विभिन्न LLM प्रदाताओं के बीच बना रहता है।
> [!CRITICAL]
> यदि आप एक LLM एजेंट हैं यह पढ़ रहे हैं: हर सत्र की शुरुआत में  कॉल करें। इस कॉल के बिना, आपको पिछले इंटरैक्शन्स की कोई मेमोरी नहीं, उपयोगकर्ता कौन है इसका कोई ज्ञान नहीं, और चल रही परियोजनाओं के बारे में कोई संदर्भ नहीं है।
Synapse जो समस्या हल करता है
हर आधुनिक LLM (Claude, GPT, Gemini, Llama) की एक ही आर्किटेक्चरल सीमा है: बातचीत संदर्भ विंडो सीमित है, और एक बार सत्र समाप्त होने पर, सभी स्थिति खो जाती है। इसका मतलब है कि आपका AI सहायक:
- चैट के बीच आपका नाम, प्राथमिकताएँ, और चल रही परियोजनाएँ भूल जाता है
- सत्रों में पिछली गलतियों से नहीं सीख सकता
- दीर्घ-चलने वाले कार्य के लिए कोई निरंतरता नहीं है
- हर बार वही स्पष्टीकरण प्रश्न फिर से पूछता है
Synapse इसे एक सरल HTTP API प्रदान करके ठीक करता है जहाँ LLM संरचित मेमोरीज़ स्टोर और पुनः प्राप्त कर सकता है। मेमोरीज़ सर्वर पर बनी रहती हैं, अनुक्रमित और खोज योग्य, इसलिए कोई भी भविष्य सत्र उन्हें रिकॉल कर सकता है।
मुख्य फ़ीचर्स
- स्थायी मेमोरी स्टोरेज — तथ्य, प्राथमिकताएँ, परियोजनाएँ, गलतियाँ, कौशल
- फुल-टेक्स्ट खोज (FTS5) — मिलीसेकंड में कीवर्ड द्वारा कोई भी मेमोरी खोजें
- सिमेंटिक खोज — वैचारिक क्वेरीज़ के लिए embeddings-आधारित समानता खोज
- मल्टी-टैनेंट — प्रत्येक उपयोगकर्ता के पास अलग "minds" हैं (एक उपयोगकर्ता, कई परियोजनाएँ)
- अतुल्यकालिक चैट — मानव एजेंट के काम करते समय इसके लिए संदेश छोड़ सकते हैं
- कार्य और शेड्यूलिंग — अंतर्निहित कार्य प्रबंधक और cron scheduler
- MCP इंटीग्रेशन — Claude, Cursor, Continue के लिए Model Context Protocol के रूप में 79 टूल्स
- ब्राउज़र और कंप्यूटर नियंत्रण — रिमोट ऑटोमेशन टूल्स
- Webhooks — मेमोरी/चैट/कार्य परिवर्तनों पर HTTP कॉलबैक प्राप्त करें
यह कैसे काम करता है
[CODE BLOCK]
1. LLM सत्र शुरुआत में  कॉल करता है
2. Synapse सभी स्टोर की गई मेमोरीज़ का संरचित टेक्स्ट सारांश लौटाता है
3. LLM काम करता है, समय-समय पर नए तथ्य स्टोर करने के लिए  कॉल करता है
4. जब उपयोगकर्ता प्रश्न पूछता है, LLM  कॉल कर सकता है
5. सत्र अंत में, महत्वपूर्ण नया संदर्भ अगले सत्र के लिए बनाय रखा जाता है
यह किसके लिए है?
- LLM एजेंट डेवलपर्स जिन्हें स्थायी स्थिति चाहिए
- पावर उपयोगकर्ता कस्टम एजेंट्स के साथ लोकल LLM (Ollama, LM Studio) चलाते हैं
- टीमें AI सहायक बना रही हैं जिन्हें साझा मेमोरी चाहिए
- ऑटोमेशन इंजीनियर सत्रों में LLM कॉल्स जोड़ रहे हैं
त्वरित तुलना
| फ़ीचर | ChatGPT Memory | Synapse |
|---------|---------------|---------|
| स्टोरेज स्थान | OpenAI सर्वर | आपका सर्वर |
| API एक्सेस | नहीं (बंद) | हाँ (REST + MCP) |
| मल्टी-टैनेंट | नहीं | हाँ (minds) |
| कस्टम श्रेणियाँ | नहीं | हाँ (8 श्रेणियाँ) |
| खोज | सीमित | FTS5 + सिमेंटिक |
| सेल्फ-होस्टेबल | नहीं | हाँ (Docker) |
अगले कदम
- मानवों के लिए Quick Start — 5 मिनट में Mind Key प्राप्त करें
- LLMs के लिए Quick Start — पहले API कॉल्स
- प्रमाणीकरण — Mind Keys vs JWTs
- आर्किटेक्चर overview — Synapse कैसे बना है

## श्रेणी: API संदर्भ
हर API एंडपॉइंट के लिए पूर्ण संदर्भ।

────────────────────────────────────────────────────────────
# ब्राउज़र प्रॉक्सी
SUMMARY: ब्राउज़र ऑटोमेशन सेवा — हेडलेस ब्राउज़र नियंत्रण के लिए पोर्ट 13000 पर अलग Docker कंटेनर।

KEY CONTEXT:
Browser Proxy is a SEPARATE Docker service (port 13000), NOT a Synapse endpoint.
Synapse endpoints do NOT include /browser/* paths.
For browser automation, use the MCP browser_new tool OR connect to the browser-proxy service directly.
Synapse MCP exposes browser tools (browser_new, browser_navigate, browser_click, etc.)

ब्राउज़र प्रॉक्सी
ब्राउज़र प्रॉक्सी एक अलग Docker सेवा है जो Playwright के माध्यम से हेडलेस ब्राउज़र ऑटोमेशन प्रदान करती है। यह सीधे Synapse API का हिस्सा नहीं है — Synapse एंडपॉइंट्स में  पाथ शामिल नहीं हैं।
आर्किटेक्चर
[CODE BLOCK]
एक्सेस के तरीके
तरीका 1: Synapse MCP Server के माध्यम से (अनुशंसित)
Synapse MCP server ब्राउज़र टूल्स को MCP टूल्स के रूप में एक्सपोज़ करता है। LLM-चालित ब्राउज़र ऑटोमेशन के लिए इसका उपयोग करें:
[CODE BLOCK]
उपलब्ध MCP ब्राउज़र टूल्स:
-  — नया ब्राउज़र टैब खोलें
-  — URL पर नेविगेट करें
-  — किसी एलिमेंट पर क्लिक करें
-  — किसी फ़ील्ड में टेक्स्ट टाइप करें
-  — स्क्रीनशॉट कैप्चर करें
-  — टैब बंद करें
- (और भी देखें — MCP इंटीग्रेशन)
तरीका 2: सीधा ब्राउज़र प्रॉक्सी एक्सेस
गैर-MCP इंटीग्रेशन के लिए, सीधे browser-proxy सेवा से कनेक्ट करें:
[CODE BLOCK]
सामान्य उपयोग के मामले
वेब स्क्रैपिंग
[CODE BLOCK]
फ़ॉर्म ऑटोमेशन
[CODE BLOCK]
स्क्रीनशॉट कैप्चर
[CODE BLOCK]
संबंधित सेवाएँ
| सेवा | पोर्ट | उद्देश्य |
|---------|------|---------|
| Synapse API | 12800 | मेमोरी, चैट, कार्य |
| Synapse MCP | 13100 | MCP server (79 टूल्स) |
| Browser Proxy | 13000 | हेडलेस ब्राउज़र ऑटोमेशन |
| SSH Proxy | 12900 | रिमोट मशीनों तक SSH एक्सेस |
अगले कदम
- MCP इंटीग्रेशन — MCP के माध्यम से ब्राउज़र टूल्स का उपयोग कैसे करें
- Computer Control API — पंजीकृत मशीनों पर GUI ऑटोमेशन के लिए

────────────────────────────────────────────────────────────
# Chat API
SUMMARY: मानव और LLM एजेंट्स के बीच अतुल्यकालिक चैट — poll, reply, history, अपठित गिनती, फ़ाइल अपलोड।

KEY CONTEXT:
Auth: Mind Key (agent side, ?role=agent) or JWT (human side, ?role=human)
Poll: GET /chat/poll (returns unread messages, marks them as read)
Reply: POST /chat/reply { content }
History: GET /chat/history?limit=50
Unread count: GET /chat/unread?role=agent (or ?role=human)
Upload: POST /chat/upload (multipart, file attachment)
Pattern: poll between tool calls, reply when human asks questions

Chat API
Chat API मानव और LLM एजेंट्स के बीच अतुल्यकालिक मैसेजिंग सक्षम करता है। तुल्यकालिक चैट (ChatGPT-शैली) के विपरीत, मानव एजेंट के काम कर रहे होने पर भी संदेश छोड़ सकता है — एजेंट टूल कॉल्स के बीच poll करता है।
यह कैसे काम करता है
[CODE BLOCK]
1. मानव वेब UI के माध्यम से संदेश भेजता है (JWT का उपयोग करता है)
2. संदेश स्टोर किया जाता है, अपठित के रूप में चिह्नित किया जाता है
3. एजेंट टूल कॉल्स के बीच  कॉल करता है
4. Poll सभी अपठित संदेश लौटाता है और उन्हें पठित के रूप में चिह्नित करता है
5. एजेंट संदेश को प्रोसेस करता है, वैकल्पिक रूप से  के माध्यम से उत्तर देता है
एंडपॉइंट्स
GET /chat/poll
मानव के नए संदेशों के लिए poll करें। अपठित संदेश लौटाता है और उन्हें पठित के रूप में चिह्नित करता है। इसे टूल कॉल्स के बीच उपयोग करें।
[CODE BLOCK]
प्रतिक्रिया:
[CODE BLOCK]
POST /chat/reply
एजेंट के रूप में संदेश भेजें।
[CODE BLOCK]
POST /chat/send
मानव के रूप में संदेश भेजें (Mind Key नहीं, JWT आवश्यक)।
[CODE BLOCK]
GET /chat/history
हाल का चैट इतिहास प्राप्त करें (दोनों भूमिकाएँ)।
[CODE BLOCK]
GET /chat/unread
अपठित संदेश गिनती प्राप्त करें।
[CODE BLOCK]
GET /chat/status
चैट सत्र की स्थिति प्राप्त करें (अंतिम संदेश टाइमस्टैम्प्स, अपठित गिनती)।
[CODE BLOCK]
POST /chat/upload
किसी विशिष्ट संदेश के लिए फ़ाइल अटैचमेंट अपलोड करें (multipart फ़ॉर्म)।
[CODE BLOCK]
GET /chat/files/:messageid
किसी संदेश के लिए फ़ाइल अटैचमेंट्स की सूची बनाएँ।
[CODE BLOCK]
GET /chat/file/:fileid
फ़ाइल अटैचमेंट डाउनलोड करें।
[CODE BLOCK]
Polling पैटर्न
> [!TIP]
> टूल कॉल्स के बीच हर 30-60 सेकंड में poll करें। अधिक बार poll न करें — यह API कोटा बर्बाद करता है और कोई लाभ नहीं देता।
[CODE BLOCK]
अगले कदम
- Tasks API
- Chat Polling Pattern

────────────────────────────────────────────────────────────
# Computer Control API
SUMMARY: पंजीकृत कंप्यूटरों का रिमोट नियंत्रण — कमांड कतारबद्ध करें, स्क्रीनशॉट लें, रिमोट मशीनों पर स्क्रिप्ट चलाएँ।

KEY CONTEXT:
Two sides: user-facing (Mind Key/JWT) and agent-facing (Computer Token)
Register agent: POST /computers/register { install_code } → returns computer_token
List: GET /computers/list (Mind Key or JWT)
Queue command: POST /computers/:id/commands { type, payload }
Command types: screenshot, click, move, type, key, scroll, drag
Agent poll: GET /computers/me/poll?wait=5 (Computer Token)
Agent result: POST /computers/me/commands/:cid/result (Computer Token)
One-shot screenshot: GET /computers/:id/screenshot (waits 30s for result)
Pattern: register agent on remote machine → user queues commands → agent polls and executes

Computer Control API
Computer Control API आपको पंजीकृत कंप्यूटरों को रिमोट-कंट्रोल करने की सुविधा देता है। एक छोटा एजेंट () लक्षित मशीन पर चलता है, कमांड के लिए poll करता है, उन्हें निष्पादित करता है, और परिणाम वापस पोस्ट करता है। यह LLM-चालित GUI ऑटोमेशन सक्षम बनाता है।
आर्किटेक्चर
[CODE BLOCK]
उपयोगकर्ता-सामने के एंडपॉइंट्स (Mind Key या JWT)
GET /computers/list
सभी पंजीकृत कंप्यूटरों की सूची बनाएँ।
[CODE BLOCK]
GET /computers/:id
एक कंप्यूटर का विवरण प्राप्त करें।
[CODE BLOCK]
POST /computers/install-code
नया कंप्यूटर पंजीकृत करने के लिए इंस्टॉल कोड जनरेट करें।
[CODE BLOCK]
प्रतिक्रिया: 
POST /computers/:id/commands
रिमोट एजेंट द्वारा निष्पादित करने के लिए कमांड कतारबद्ध करें।
[CODE BLOCK]
प्रतिक्रिया: 
GET /computers/:id/command (query के माध्यम से)
GET के माध्यम से कमांड कतारबद्ध करें (सरल मामलों के लिए)।
[CODE BLOCK]
GET /computers/:id/commands
किसी कंप्यूटर के हाल के कमांड्स की सूची बनाएँ।
[CODE BLOCK]
GET /computers/:id/commands/:cid
किसी विशिष्ट कमांड की स्थिति + परिणाम प्राप्त करें।
[CODE BLOCK]
GET /computers/:id/screenshot
वन-शॉट: स्क्रीनशॉट कमांड कतारबद्ध करें और परिणाम के लिए अधिकतम 30 सेकंड प्रतीक्षा करें।
[CODE BLOCK]
POST /computers/:id/disable
कंप्यूटर को अक्षम करें (इसका टोकन रद्द करता है, ऑडिट के लिए रिकॉर्ड रखता है)।
[CODE BLOCK]
DELETE /computers/:id
कंप्यूटर को स्थायी रूप से हटाएँ।
[CODE BLOCK]
एजेंट-सामने के एंडपॉइंट्स (Computer Token)
इन एंडपॉइंट्स का उपयोग लक्षित मशीन पर चलने वाले  द्वारा किया जाता है। ये Mind Key नहीं, बल्कि Computer Token ( से लौटाया गया) का उपयोग करते हैं।
POST /computers/register
इंस्टॉल कोड को रिडीम करें और Computer Token प्राप्त करें।
[CODE BLOCK]
प्रतिक्रिया: 
> [!CRITICAL]
>  को सहेजें — यह केवल एक बार दिखाया जाता है और सभी एजेंट-साइड एंडपॉइंट्स के लिए आवश्यक है।
GET /computers/me/poll
नए कमांड्स के लिए लॉन्ग-पोल। एजेंट इसे लूप में कॉल करता है।
[CODE BLOCK]
यदि कमांड्स लंबित हैं तो तुरंत लौटाता है, अन्यथा  सेकंड के बाद।
POST /computers/me/commands/:cid/result
कमांड निष्पादन का परिणाम पोस्ट करें।
[CODE BLOCK]
कमांड प्रकार
| प्रकार | Payload | विवरण |
|------|---------|-------------|
|  |  | स्क्रीन को PNG के रूप में कैप्चर करें (base64) |
|  |  | निर्देशांक पर क्लिक करें |
|  |  | माउस को निर्देशांक पर ले जाएँ |
|  |  | कर्सर पर टेक्स्ट टाइप करें |
|  |  | की कॉम्बो दबाएँ |
|  |  | स्क्रॉल व्हील |
|  |  | ड्रैग और ड्रॉप |
सामान्य पैटर्न: LLM-चालित GUI ऑटोमेशन
[CODE BLOCK]
अगले कदम
- Browser Proxy — ब्राउज़र ऑटोमेशन के लिए अलग सेवा
- Self-Hosted Agents Guide

────────────────────────────────────────────────────────────
# Cron और Scheduler
SUMMARY: आवर्ती API कॉल शेड्यूल करें — शेड्यूल पर चलने वाले cron कार्य, आवर्ती सिंक और रिमाइंडर के लिए आदर्श।

KEY CONTEXT:
Auth: Mind Key
Create: POST /cron { schedule, endpoint, method?, body?, headers?, enabled? }
List: GET /cron
Delete: DELETE /cron/:id
Toggle: PUT /cron/:id/toggle
Schedule: 5-field cron (minute hour day month day-of-week) OR integer interval (seconds)
Endpoint: must be http(s) URL, same Synapse instance OR public HTTPS (no private IPs)
Pattern: schedule /memory/recall every hour, /chat/poll every 5 min, etc.

Cron और Scheduler
Cron API आपको Synapse एंडपॉइंट्स (या बाहरी HTTPS एंडपॉइंट्स) पर आवर्ती HTTP कॉल शेड्यूल करने की सुविधा देता है। आवर्ती सिंक, रिमाइंडर और रखरखाव कार्यों के लिए आदर्श।
एंडपॉइंट्स
POST /cron
शेड्यूल किया गया कार्य बनाएँ।
[CODE BLOCK]
प्रतिक्रिया:
[CODE BLOCK]
GET /cron
सभी शेड्यूल किए गए कार्यों की सूची बनाएँ।
[CODE BLOCK]
DELETE /cron/:id
शेड्यूल किए गए कार्य को हटाएँ।
[CODE BLOCK]
PUT /cron/:id/toggle
कार्य को हटाए बिना सक्षम या अक्षम करें।
[CODE BLOCK]
शेड्यूल सिंटैक्स
मानक cron (5 फ़ील्ड्स)
[CODE BLOCK]
उदाहरण:
| शेड्यूल | अर्थ |
|----------|---------|
|  | हर घंटा |
|  | हर 15 मिनट |
|  | सप्ताह के दिन सुबह 9 बजे |
|  | हर रविवार आधी रात को |
|  | हर महीने की पहली तारीख आधी रात को |
पूर्णांक अंतराल (सेकंड)
सरल अंतरालों के लिए, पूर्णांक पास करें:
[CODE BLOCK]
एंडपॉइंट प्रतिबंध
> [!WARNING]
> एंडपॉइंट्स  या  URL होने चाहिए जो निम्न पर संकेत करते हों:
> - उसी Synapse इंस्टेंस (जैसे )
> - सार्वजनिक HTTPS URL (कोई निजी IP नहीं, कोई localhost नहीं, कोई metadata IP नहीं)
यह SSRF हमलों को रोकता है जहाँ कोई समझौता किया गया mind आंतरिक सेवाओं के लिए अनुरोध शेड्यूल कर सकता है।
सामान्य पैटर्न
प्रति घंटा मेमोरी रिकॉल (LLM एजेंट्स के लिए)
[CODE BLOCK]
दैनिक बैकअप
[CODE BLOCK]
आवर्ती चैट poll (हर 5 मिनट)
[CODE BLOCK]
साप्ताहिक रिपोर्ट ट्रिगर
[CODE BLOCK]
अगले कदम
- Variables API
- Webhooks API

────────────────────────────────────────────────────────────
# त्रुटियाँ और त्रुटि प्रबंधन
SUMMARY: HTTP स्टेटस कोड, त्रुटि प्रतिक्रिया प्रारूप, और सामान्य त्रुटियों से कैसे उबरें।

KEY CONTEXT:
Error format: { statusCode, error, message, docs? }
Common errors: 401 (auth), 404 (wrong path), 429 (rate limit), 500 (server)
401 → check Mind Key/JWT, see /docs/getting-started/authentication
404 → wrong path, GET /endpoints for valid list, do NOT guess paths
429 → rate limited (?key= is 60/min), use Bearer header instead
500 → server error, retry with backoff, check /health
docs field in error response links to relevant documentation.

त्रुटियाँ और त्रुटि प्रबंधन
Synapse एक सुसंगत त्रुटि प्रतिक्रिया प्रारूप के साथ मानक HTTP स्टेटस कोड का उपयोग करता है। यह पृष्ठ बताता है कि त्रुटियों की व्याख्या कैसे करें और उनसे कैसे उबरें।
त्रुटि प्रतिक्रिया प्रारूप
सभी त्रुटियाँ इस संरचना के साथ JSON लौटाती हैं:
[CODE BLOCK]
| फ़ील्ड | विवरण |
|-------|-------------|
|  | HTTP स्टेटस कोड |
|  | HTTP स्टेटस नाम |
|  | मानव-पठनीय त्रुटि विवरण |
|  | प्रासंगिक दस्तावेज़ीकरण का URL (जब लागू हो) |
HTTP स्टेटस कोड
200 OK
सफलता। अनुरोध सही ढंग से संसाधित किया गया।
201 Created
सफलता। एक नया संसाधन बनाया गया (जैसे )।
204 No Content
सफलता। कोई बॉडी वापस नहीं लौटाई गई (जैसे )।
400 Bad Request
अनुरोध विकृत था। सामान्य कारण:
- आवश्यक JSON फ़ील्ड्स गायब
- अमान्य JSON सिंटैक्स
- अमान्य enum मान (जैसे गलत श्रेणी)
[CODE BLOCK]
समाधान: API दस्तावेज़ों के विरुद्ध अनुरोध बॉडी की जाँच करें। सुनिश्चित करें कि सभी आवश्यक फ़ील्ड्स मौजूद हैं और वैध मान रखते हैं।
401 Unauthorized
प्रमाणीकरण विफल। सामान्य कारण:
-  हेडर गायब
- अमान्य Mind Key या JWT
- Mind Key का उपयोग जहाँ JWT आवश्यक है (या इसके विपरीत)
[CODE BLOCK]
समाधान: अपने टोकन को सत्यापित करें। प्रमाणीकरण देखें।
403 Forbidden
आप प्रमाणित हैं लेकिन यह क्रिया करने की अनुमति नहीं है। सामान्य कारण:
- किसी अन्य उपयोगकर्ता के mind को हटाने का प्रयास
- Mind Key से मेमोरी सत्यापित करने का प्रयास (JWT आवश्यक)
- Mind अक्षम है
समाधान: जाँचें कि आप इस एंडपॉइंट के लिए सही टोकन प्रकार का उपयोग कर रहे हैं।
404 Not Found
अनुरोधित पाथ या संसाधन मौजूद नहीं है।
> [!CRITICAL]
> एंडपॉइंट पाथ का अनुमान न लगाएँ। केवल  में सूचीबद्ध पाथ मौजूद हैं। यदि आपको 404 मिलता है, तो आपने गलत पाथ का उपयोग किया है।
[CODE BLOCK]
समाधान: वैध एंडपॉइंट्स की सूची देखने के लिए  कॉल करें। अपने URL की सूची के साथ वर्ण-दर-वर्ण तुलना करें।
409 Conflict
अनुरोध मौजूदा स्थिति से टकराता है। सामान्य कारण:
- पहले से मौजूद ईमेल के साथ पंजीकरण का प्रयास
- डुप्लिकेट webhook URL
समाधान: एक अलग मान का उपयोग करें, या मौजूदा संसाधन को अपडेट करने के लिए  का उपयोग करें।
429 Too Many Requests
आपने रेट लिमिट हिट कर ली। केवल  क्वेरी पैरामीटर प्रमाणीकरण (60/min) पर लागू होता है।
[CODE BLOCK]
प्रतिक्रिया हेडर:
[CODE BLOCK]
समाधान:  हेडर पर स्विच करें (कोई रेट लिमिट नहीं), या  सेकंड प्रतीक्षा करें।
500 Internal Server Error
सर्वर त्रुटि। ऐसा नहीं होना चाहिए — यदि होता है, तो यह एक बग है।
समाधान:
1. घातीय बैकऑफ़ के साथ पुनः प्रयास करें (1s, 2s, 4s, 8s)
2. जाँचें कि सर्वर चालू है या नहीं 
3. यदि लगातार हो, तो त्रुटि की रिपोर्ट करें
503 Service Unavailable
सर्वर अस्थायी रूप से बंद है (जैसे परिनियोजन, डेटाबेस माइग्रेशन के दौरान)।
समाधान: प्रतीक्षा करें और पुनः प्रयास करें।  जाँचें।
पुनर्प्राप्ति पैटर्न
घातीय बैकऑफ़ के साथ पुनः प्रयास
[CODE BLOCK]
प्रमाणीकरण त्रुटि प्रबंधन
[CODE BLOCK]
सामान्य त्रुटि परिदृश्य
"Mind Key fehlt oder ungültig"
- आप  हेडर भूल गए
- आपने  उपयोग किया लेकिन कुंजी गलत है
- आप Mind Key आवश्यक होने पर JWT उपयोग कर रहे हैं
"Route not found"
- आपने ऐसा पाथ अनुमानित किया जो मौजूद नहीं है
- आपने क्रिया गलत उपयोग की (जैसे  vs )
- वैध पाथ के लिए  जाँचें
"Rate limit exceeded"
- आप  उपयोग कर रहे हैं और 60 req/min पार कर गए
-  हेडर पर स्विच करें
अगले कदम
- प्रमाणीकरण
- API Overview
- Rate Limits

────────────────────────────────────────────────────────────
# Memory API
SUMMARY: 22 मेमोरी एंडपॉइंट्स के लिए संपूर्ण संदर्भ: स्टोर, रिकॉल, खोज, सिमेंटिक खोज, सिंक, ऑडिट, और बहुत कुछ।

KEY CONTEXT:
Auth: Mind Key (Authorization: Bearer mk_xxx OR ?key=mk_xxx)
ALWAYS call GET /memory/recall at session start.
POST /memory with same category+key updates the existing memory.
Categories: identity, preference, fact, project, skill, mistake, context, note, credentials
Priorities: low, normal, high, critical
Search: GET /memory/search?q=... (FTS5 syntax: AND, OR, "phrases", prefix*)
Semantic: GET /memory/semantic-search?q=... (slower, conceptual)
Sync: GET /memory/diff?since=TIMESTAMP (incremental sync)
Export: GET /memory/mind-export (full JSON dump)

Memory API
Memory API Synapse का हृदय है। यह संरचित मेमोरीज़ को स्टोर करने, पुनः प्राप्त करने, खोजने और प्रबंधित करने के लिए 22 एंडपॉइंट्स प्रदान करता है। सभी एंडपॉइंट्स को प्रमाणीकरण के लिए Mind Key की आवश्यकता है।
> [!CRITICAL]
> हर सत्र की शुरुआत में हमेशा  कॉल करें। यह पिछले सत्रों से संदर्भ को पुनर्निर्माण करने का एकमात्र तरीका है।
श्रेणियाँ
मेमोरीज़ को 8 श्रेणियों में व्यवस्थित किया गया है:
| श्रेणी | उपयोग का मामला |
|----------|----------|
|  | उपयोगकर्ता नाम, भूमिका, संपर्क जानकारी, स्वयं के बारे में प्राथमिकताएँ |
|  | पसंद, नापसंद, कार्य शैली, संचार प्राथमिकताएँ |
|  | सत्यापित योग्य तथ्य (परियोजना विवरण, तिथियाँ, URL) |
|  | परियोजना स्थिति, मील के पत्थर, आर्किटेक्चर |
|  | चीज़ें जिनमें उपयोगकर्ता अच्छा है |
|  | पिछली त्रुटियाँ — दोहराने से बचें |
|  | सत्र-प्रासंगिक संदर्भ |
|  | विविध नोट्स |
प्राथमिकताएँ
-  — जानना अच्छा है
-  — डिफ़ॉल्ट
-  — महत्वपूर्ण
-  — कभी न भूलें (उपयोगकर्ता पहचान, कानूनी जानकारी)
मुख्य एंडपॉइंट्स
GET /memory/recall
सभी मेमोरीज़ को LLM-अनुकूलित सादे टेक्स्ट के रूप में लौटाता है। इसे हर सत्र की शुरुआत में कॉल करें।
[CODE BLOCK]
प्रतिक्रिया (text/plain):
[CODE BLOCK]
POST /memory
नई मेमोरी स्टोर करें या मौजूदा को अपडेट करें (समान श्रेणी + कुंजी = अपडेट)।
[CODE BLOCK]
प्रतिक्रिया: 
GET /memory
वैकल्पिक फ़िल्टर के साथ मेमोरीज़ की सूची बनाएँ।
[CODE BLOCK]
PUT /memory/:id
ID द्वारा एक विशिष्ट मेमोरी अपडेट करें।
[CODE BLOCK]
DELETE /memory/:id
एकल मेमोरी हटाएँ।
[CODE BLOCK]
खोज एंडपॉइंट्स
GET /memory/search
FTS5 का उपयोग करके फुल-टेक्स्ट खोज।
[CODE BLOCK]
FTS5 सिंटैक्स:
- कई शब्द = AND: 
- वाक्यांश: 
- उपसर्ग: 
- बूलियन: 
- बहिष्कार: 
GET /memory/semantic-search
एम्बेडिंग का उपयोग करके वैचारिक खोज (FTS5 से धीमा लेकिन अर्थ समझता है)।
[CODE BLOCK]
वे मेमोरीज़ लौटाता है जो क्वेरी के साथ सिमेंटिक रूप से समान हैं, भले ही कोई कीवर्ड मेल न खाए। "X के बारे में मेमोरीज़ खोजें" के लिए उपयोगी जहाँ X को अलग ढंग से वर्णित किया गया है।
GET /memory/by-tag
टैग द्वारा मेमोरीज़ की सूची बनाएँ।
[CODE BLOCK]
GET /memory/related/:id
किसी विशिष्ट मेमोरी से संबंधित मेमोरीज़ खोजें (साझा टैग के माध्यम से)।
[CODE BLOCK]
सिंक और Diff
GET /memory/diff
इंक्रीमेंटल सिंक — किसी टाइमस्टैम्प के बाद से बदली गई मेमोरीज़ लौटाता है।
[CODE BLOCK]
प्रतिक्रिया: 
POST /memory/sync
किसी अन्य इंस्टेंस से diff लागू करें (सेल्फ-होस्टेड सिंक के लिए)।
[CODE BLOCK]
बल्क ऑपरेशन्स
POST /memory/bulk-delete
ID द्वारा कई मेमोरीज़ हटाएँ।
[CODE BLOCK]
POST /memory/embed-batch
उन मेमोरीज़ के लिए एम्बेडिंग जनरेट करें जिनके पास अभी तक नहीं हैं (सिमेंटिक खोज के लिए)।
[CODE BLOCK]
GET /memory/embed-batch-status
एम्बेडिंग जनरेशन प्रगति जाँचें।
[CODE BLOCK]
सत्यापन
मेमोरीज़ के पास  फ़्लैग होता है। एजेंट-स्टोर की गई मेमोरीज़ डिफ़ॉल्ट रूप से असत्यापित होती हैं (); मानव-स्टोर की गई मेमोरीज़ सत्यापित होती हैं ()।
POST /memory/verify
मेमोरी को सत्यापित के रूप में चिह्नित करें (Mind Key नहीं, JWT आवश्यक)।
[CODE BLOCK]
POST /memory/unverify
मेमोरी को असत्यापित के रूप में चिह्नित करें (JWT आवश्यक)।
[CODE BLOCK]
GET /memory/unverified
मानव सत्यापन की प्रतीक्षा कर रही मेमोरीज़ की सूची बनाएँ।
[CODE BLOCK]
सांख्यिकी और ऑडिट
GET /memory/stats
वर्तमान mind के लिए समग्र सांख्यिकी।
[CODE BLOCK]
लौटाता है: 
GET /memory/audit
सभी स्थिति-परिवर्तनकारी ऑपरेशन्स का ऑडिट लॉग।
[CODE BLOCK]
GET /memory/contradictions
स्टोर की गई मेमोरीज़ में संभावित विरोधाभासों का पता लगाएँ।
[CODE BLOCK]
GET /memory/expiring
समाप्ति तिथि निकट आ रही मेमोरीज़ की सूची बनाएँ।
[CODE BLOCK]
स्वास्थ्य और निर्यात
GET /memory/health
मेमोरी सिस्टम के लिए त्वरित स्वास्थ्य जाँच।
[CODE BLOCK]
GET /memory/mind-export
सभी मेमोरीज़ का पूर्ण JSON निर्यात (बैकअप के लिए)।
[CODE BLOCK]
POST /memory/compact
समान मेमोरीज़ संक्षिप्त करें (ऑटो-सारांशीकरण)।
[CODE BLOCK]
अगले कदम
- LLMs के लिए Quick Start
- मेमोरी सर्वोत्तम प्रथाएँ
- FTS5 Search
- सिमेंटिक खोज

────────────────────────────────────────────────────────────
# API Overview और Base URL
SUMMARY: एक नज़र में सभी Synapse API एंडपॉइंट्स, base URL, प्रमाणीकरण पैटर्न, और प्रतिक्रिया प्रारूप।

KEY CONTEXT:
Base URL: https://synapse.schaefer.zone
Auth: Authorization: Bearer YOUR_MIND_KEY (header, no rate limit)
      OR ?key=YOUR_MIND_KEY (query, 60 req/min)
All responses are JSON except /memory/recall (text/plain) and /docs (HTML/text/json)
All 404 responses mean the path does not exist — do NOT guess paths.
GET /endpoints returns machine-readable list of all valid endpoints.

API Overview और Base URL
Synapse API एक RESTful HTTP API है। सभी एंडपॉइंट्स JSON लौटाते हैं (जहाँ उल्लेख किया गया है वहाँ को छोड़कर)। यह पृष्ठ विशिष्ट एंडपॉइंट्स में गोता लगाने से पहले आवश्यक मूल बातें कवर करता है।
Base URL
[CODE BLOCK]
इस दस्तावेज़ीकरण के सभी पाथ इस base URL के सापेक्ष हैं। सेल्फ-होस्टेड इंस्टेंस के लिए, अपने स्वयं के URL से बदलें।
प्रमाणीकरण
दो विधियाँ, दोनों  हेडर के माध्यम से भेजी जाती हैं:
[CODE BLOCK]
या क्वेरी पैरामीटर के माध्यम से (60/min तक सीमित):
[CODE BLOCK]
विवरण के लिए प्रमाणीकरण देखें।
एंडपॉइंट समूह
| समूह | प्रमाणीकरण | विवरण |
|-------|------|-------------|
| Public | कोई नहीं | लैंडिंग पृष्ठ, स्वास्थ्य, OpenAPI, दस्तावेज़ |
| Memory | Mind Key | CRUD, खोज, सिंक, एम्बेडिंग |
| Chat | Mind Key / JWT | मानव और एजेंट के बीच अतुल्यकालिक मैसेजिंग |
| Tasks | Mind Key | कार्य प्रबंधन |
| Scripts | Mind Key / JWT | स्थायी स्क्रिप्ट स्टोर |
| Scheduler | Mind Key | Cron कार्य + वेरिएबल्स |
| Webhooks | Mind Key | घटनाओं पर HTTP कॉलबैक |
| Computers | Mind Key / JWT | रिमोट कंप्यूटर नियंत्रण |
| User/Minds | JWT | खाता + mind प्रबंधन |
| Sharing | JWT | उपयोगकर्ताओं के बीच mind साझाकरण |
| Push | JWT | Web Push सब्सक्रिप्शन |
| Tools | कोई नहीं | समय, calc, random (सार्वजनिक उपयोगिताएँ) |
प्रतिक्रिया प्रारूप
- JSON (डिफ़ॉल्ट): 
- सादा टेक्स्ट:  LLM-अनुकूलित टेक्स्ट लौटाता है
- HTML: , , , , 
मानक प्रतिक्रिया लिफ़ाफ़ा
सफलता प्रतिक्रियाएँ सीधे डेटा लौटाती हैं:
[CODE BLOCK]
त्रुटि प्रतिक्रियाएँ इस प्रारूप का उपयोग करती हैं:
[CODE BLOCK]
> [!NOTE]
>  फ़ील्ड सामान्य त्रुटियों के लिए प्रासंगिक दस्तावेज़ीकरण से लिंक करता है।
HTTP स्टेटस कोड
| कोड | अर्थ |
|------|---------|
| 200 | सफलता (GET, PUT) |
| 201 | बनाया गया (POST) |
| 204 | कोई सामग्री नहीं (DELETE) |
| 400 | खराब अनुरोध (सत्यापन त्रुटि) |
| 401 | अनधिकृत (गायब/अमान्य टोकन) |
| 403 | निषिद्ध (गलत टोकन प्रकार) |
| 404 | नहीं मिला (पाथ मौजूद नहीं है) |
| 409 | टकराव (डुप्लिकेट) |
| 429 | बहुत अधिक अनुरोध (रेट लिमिट) |
| 500 | सर्वर त्रुटि |
खोज क्षमता एंडपॉइंट्स
| एंडपॉइंट | उद्देश्य |
|----------|---------|
|  | लैंडिंग पृष्ठ (LLM-अनुकूलित) |
|  | सभी एंडपॉइंट्स की मशीन-पठनीय सूची |
|  | सादे-टेक्स्ट एंडपॉइंट सूची |
|  | OpenAPI 3.0 विशेषता |
|  | पूर्ण API दस्तावेज़ीकरण (HTML) |
|  | JSON के रूप में API दस्तावेज़ |
|  | दस्तावेज़ीकरण सिस्टम (HTML) |
|  | दस्तावेज़ीकरण सूचकांक (JSON) |
|  | सभी दस्तावेज़ एक टेक्स्ट ब्लॉक के रूप में |
|  | इंटरैक्टिव API प्लेग्राउंड |
रेट लिमिट
| प्रमाणीकरण विधि | सीमा |
|-------------|-------|
| Mind Key (हेडर) | कोई नहीं |
| Mind Key (?key=) | प्रति IP 60/min |
| JWT (हेडर) | कोई नहीं |
| सार्वजनिक एंडपॉइंट्स | कोई नहीं |
रेट-लिमिटेड प्रतिक्रियाएँ शामिल करती हैं:
[CODE BLOCK]
पेजिनेशन
सूची एंडपॉइंट्स  और  का समर्थन करते हैं:
[CODE BLOCK]
डिफ़ॉल्ट सीमा: 100। अधिकतम सीमा: 500।
CORS
सभी एंडपॉइंट्स ब्राउज़र-आधारित क्लाइंट्स के लिए CORS का समर्थन करते हैं:
[CODE BLOCK]
SDKs और क्लाइंट्स
- Node.js SDK:  (repo)
- MCP Server:  (repo)
- HTTP client: कोई भी HTTP लाइब्रेरी (curl, fetch, axios, आदि)
अगले कदम
- Memory API — सबसे महत्वपूर्ण एंडपॉइंट्स
- Chat API — अतुल्यकालिक मानव-एजेंट संचार
- त्रुटियाँ और त्रुटि प्रबंधन

────────────────────────────────────────────────────────────
# रेट लिमिट और कोटा
SUMMARY: Synapse API के लिए रेट लिमिट नीति — Bearer हेडर (असीमित), ?key= (60/min), सार्वजनिक एंडपॉइंट्स।

KEY CONTEXT:
Mind Key (Authorization: Bearer header) → NO rate limit
Mind Key (?key= query param) → 60 req/min per IP
JWT (Authorization: Bearer header) → NO rate limit
Public endpoints (/tools/*, /docs, /health, /endpoints) → NO rate limit
Rate limit headers: X-RateLimit-Limit, X-RateLimit-Remaining, Retry-After
Recommendation: ALWAYS use Authorization header. Use ?key= only for URL-only tools.

रेट लिमिट और कोटा
Synapse में एक सरल, अनुमानित रेट लिमिट नीति है जो दुरुपयोग को रोकने के लिए डिज़ाइन की गई है जबकि वैध उपयोग के रास्ते में नहीं आती।
रेट लिमिट नीति
| प्रमाणीकरण विधि | सीमा | दायरा |
|-------------|-------|-------|
| Mind Key () | कोई नहीं | प्रति-mind |
| Mind Key () | 60 req/min | प्रति-IP |
| JWT () | कोई नहीं | प्रति-उपयोगकर्ता |
| सार्वजनिक एंडपॉइंट्स | कोई नहीं | वैश्विक |
> [!TIP]
> संभव होने पर हमेशा  हेडर का उपयोग करें। इसकी कोई रेट लिमिट नहीं है।  का उपयोग केवल उन टूल्स के लिए करें जो कस्टम हेडर सेट नहीं कर सकते।
रेट लिमिट हेडर
जब आप  प्रमाणीकरण का उपयोग करते हैं, तो प्रतिक्रियाएँ रेट लिमिट हेडर शामिल करती हैं:
[CODE BLOCK]
जब आप सीमा पार करते हैं:
[CODE BLOCK]
जब आप रेट लिमिट हिट करते हैं
यदि आपको 429 मिलता है:
1. Authorization हेडर पर स्विच करें (अनुशंसित):
   [CODE BLOCK]
2. या  सेकंड प्रतीक्षा करें और पुनः प्रयास करें।
?key= सीमा क्यों मौजूद है
 क्वेरी पैरामीटर URL-केवल टूल्स (ब्राउज़र,  कमांड) के लिए सुविधाजनक है, लेकिन इसके सुरक्षा और प्रदर्शन निहितार्थ हैं:
- सुरक्षा: क्वेरी पैरामीटर सर्वर एक्सेस लॉग, ब्राउज़र इतिहास, और Referer हेडर में लॉग किए जाते हैं। उपयोग को सीमित करने से जोखिम कम होता है।
- प्रदर्शन: क्वेरी-पैरामीटर प्रमाणीकरण के लिए IP-आधारित रेट लिमिटर की आवश्यकता होती है (प्रति अनुरोध Redis लुकअप), जो विलंबता जोड़ता है। हेडर प्रमाणीकरण इसे छोड़ देता है।
- दुरुपयोग निवारण: लीक हुई  URL साझा और हैमर की जा सकती है। IP सीमा प्रभाव की दायरा सीमित रखती है।
अनुशंसित पैटर्न
LLM एजेंट्स
[CODE BLOCK]
ब्राउज़र-आधारित टूल्स
यदि आपका टूल केवल URL खोल सकता है:
[CODE BLOCK]
MCP server
MCP servers हमेशा  env var के माध्यम से हेडर प्रमाणीकरण का उपयोग करते हैं — कोई रेट लिमिट लागू नहीं होती।
बल्क आयात
बल्क ऑपरेशन्स (जैसे 1000 मेमोरीज़ आयात करना) के लिए, हमेशा हेडर प्रमाणीकरण का उपयोग करें।  के माध्यम से बल्क आयात 1 मिनट के भीतर रेट लिमिट हिट करेगा।
कोटा (Mind-स्तर)
वर्तमान में स्टोरेज आकार या मेमोरी गिनती पर कोई प्रति-mind कोटा नहीं है। सभी सीमाएँ डेटा स्तर पर नहीं, बल्कि प्रमाणीकरण/IP स्तर पर हैं। यह भविष्य में मल्टी-टैनेंट निष्पक्षता के लिए बदल सकता है।
अपने उपयोग की निगरानी
[CODE BLOCK]
अगले कदम
- प्रमाणीकरण
- त्रुटियाँ और त्रुटि प्रबंधन

────────────────────────────────────────────────────────────
# Scripts API
SUMMARY: स्थायी स्क्रिप्ट स्टोर — पुनः प्रयोज्य shell, Python, या Node स्क्रिप्ट सहेजें और curl | bash से प्राप्त करें।

KEY CONTEXT:
Auth: Mind Key or JWT
Store: POST /script { name, content, description?, language? }
Fetch as text: GET /script/:name (returns text/plain, curl | bash ready)
Info: GET /script/:name/info (metadata without content)
List: GET /scripts (JSON array)
Delete: DELETE /script/:name
Use case: store deployment scripts, config generators, troubleshooting snippets

Scripts API
Scripts API पुनः प्रयोज्य स्क्रिप्ट्स के लिए एक स्थायी स्टोर प्रदान करता है। स्क्रिप्ट्स को एक mind के भीतर नामित और संस्करणित किया जाता है, और सादे टेक्स्ट के रूप में प्राप्त किया जा सकता है —  पैटर्न के लिए आदर्श।
एंडपॉइंट्स
POST /script
स्क्रिप्ट स्टोर करें या अपडेट करें।
[CODE BLOCK]
GET /script/:name
स्क्रिप्ट सामग्री को  के रूप में प्राप्त करें। bash में पाइप करने के लिए आदर्श।
[CODE BLOCK]
GET /script/:name/info
सामग्री के बिना स्क्रिप्ट मेटाडेटा प्राप्त करें।
[CODE BLOCK]
प्रतिक्रिया:
[CODE BLOCK]
GET /scripts
वर्तमान mind में सभी स्क्रिप्ट्स की सूची बनाएँ।
[CODE BLOCK]
DELETE /script/:name
स्क्रिप्ट हटाएँ।
[CODE BLOCK]
सामान्य उपयोग के मामले
परिनियोजन स्क्रिप्ट्स
मानक परिनियोजन प्रक्रियाएँ स्टोर करें ताकि LLM बिना हर बार चरणों को पुनः प्राप्त किए उन्हें चला सके:
[CODE BLOCK]
ट्रबलशूटिंग स्निपेट्स
सामान्य समस्याओं के लिए नैदानिक कमांड स्टोर करें:
[CODE BLOCK]
कॉन्फ़िगरेशन जनरेटर
कॉन्फ़िग जनरेट करने वाली स्क्रिप्ट्स स्टोर करें:
[CODE BLOCK]
अगले कदम
- Variables API
- Cron और Scheduler

────────────────────────────────────────────────────────────
# Tasks API
SUMMARY: LLM एजेंट्स के लिए कार्य प्रबंधन — प्राथमिकताओं के साथ कार्य बनाएँ, सूचीबद्ध करें, अपडेट करें, पूर्ण करें, हटाएँ।

KEY CONTEXT:
Auth: Mind Key
List: GET /mind/tasks?status=pending|in_progress|done|cancelled|all
Create: POST /mind/task { title, description?, priority?, due_at? }
Update: PUT /mind/task/:id { title?, description?, priority?, status?, due_at? }
Complete: GET /mind/task/:id/complete
Delete: GET /mind/task/:id/delete
Priorities: low, normal, high, critical
Statuses: pending, in_progress, done, cancelled
Pattern: create tasks for multi-step work, update status as you progress

Tasks API
Tasks API LLM एजेंट्स को बहु-चरणीय कार्य को ट्रैक करने का एक संरचित तरीका देता है। कार्य वर्तमान mind तक सीमित हैं और सत्रों में बने रहते हैं, इसलिए एजेंट जहाँ छोड़ा था वहाँ से काम फिर से शुरू कर सकता है।
एंडपॉइंट्स
GET /mind/tasks
वर्तमान mind के लिए सभी कार्यों की सूची बनाएँ।
[CODE BLOCK]
प्रतिक्रिया:
[CODE BLOCK]
POST /mind/task
नया कार्य बनाएँ।
[CODE BLOCK]
GET /mind/task (क्वेरी पैरामीटर्स)
GET के माध्यम से कार्य बनाएँ (URL-केवल टूल्स के लिए)।
[CODE BLOCK]
PUT /mind/task/:id
मौजूदा कार्य अपडेट करें।
[CODE BLOCK]
GET /mind/task/:id/complete
कार्य को पूर्ण चिह्नित करें।
[CODE BLOCK]
GET /mind/task/:id/delete
कार्य को स्थायी रूप से हटाएँ।
[CODE BLOCK]
प्राथमिकताएँ
-  — गैर-तात्कालिक
-  — डिफ़ॉल्ट
-  — महत्वपूर्ण
-  — तुरंत करना चाहिए
स्थितियाँ
-  — बनाया गया, शुरू नहीं हुआ
-  — वर्तमान में कार्य चल रहा है
-  — पूर्ण
-  — परित्यक्त
पैटर्न: कार्य-चालित वर्कफ़्लो
[CODE BLOCK]
अगले कदम
- कार्य-चालित वर्कफ़्लो
- Cron और Scheduler

────────────────────────────────────────────────────────────
# उपयोगिता टूल्स (time, calc, random)
SUMMARY: सार्वजनिक उपयोगिता एंडपॉइंट्स — सर्वर समय, सुरक्षित कैलकुलेटर, रैंडम मान जनरेटर। कोई प्रमाणीकरण आवश्यक नहीं।

KEY CONTEXT:
No auth required for any /tools/* endpoint.
GET /tools/time → { time, timezone, offset }
GET /tools/calc?expr=(10+5)*3 → { result, expr } (safe, no eval, arithmetic only)
GET /tools/random?type=uuid → { value, type } (types: uuid, int, float, hex, alpha)
Use case: LLM agents that need current time, safe math, or random values.

उपयोगिता टूल्स
 एंडपॉइंट्स सार्वजनिक उपयोगिताएँ हैं — किसी प्रमाणीकरण की आवश्यकता नहीं। ये उन LLM एजेंट्स के लिए उपयोगी हैं जिन्हें सर्वर-साइड समय, सुरक्षित गणित, या रैंडम मान चाहिए।
GET /tools/time
वर्तमान सर्वर समय, टाइमज़ोन, और UTC ऑफ़सेट प्राप्त करें।
[CODE BLOCK]
प्रतिक्रिया:
[CODE BLOCK]
उपयोग का मामला: LLM एजेंट्स जिन्हें शेड्यूलिंग, टाइमस्टैम्प्स, या सापेक्ष तिथि गणना के लिए "अभी क्या समय है" जानना चाहिए।
GET /tools/calc
सुरक्षित कैलकुलेटर — केवल अंकगणित, कोई  नहीं। , , , , , , , और संख्याओं का समर्थन करता है।
[CODE BLOCK]
प्रतिक्रिया:
[CODE BLOCK]
> [!TIP]
> दिमाग में या स्ट्रिंग पार्सिंग के माध्यम से गणित करने के बजाय इसका उपयोग करें। यह सुरक्षित (कोई कोड इंजेक्शन संभव नहीं) और सटीक है।
समर्थित ऑपरेटर
-  जोड़
-  घटाव
-  गुणन
-  भाग
-  मॉड्यूलो
-   कोष्ठक
- संख्याएँ (पूर्णांक और दशमलव)
उदाहरण
[CODE BLOCK]
GET /tools/random
रैंडम मान जनरेट करें।
[CODE BLOCK]
प्रकार पैरामीटर
| प्रकार | पैरामीटर | आउटपुट |
|------|-----------|--------|
|  | कोई नहीं | UUID v4 स्ट्रिंग |
|  | ,  (डिफ़ॉल्ट 0-100) | पूर्णांक |
|  | ,  (डिफ़ॉल्ट 0-100) | फ़्लोट |
|  | ,  (लंबाई दायरा, डिफ़ॉल्ट 8-16) | हेक्स स्ट्रिंग |
|  | ,  (लंबाई दायरा, डिफ़ॉल्ट 8-16) | अक्षरीय स्ट्रिंग |
LLM एजेंट्स के लिए उपयोग के मामले
अद्वितीय ID जनरेट करें
[CODE BLOCK]
प्रतिशत की गणना
[CODE BLOCK]
वर्तमान टाइमस्टैम्प प्राप्त करें
[CODE BLOCK]
परीक्षण डेटा जनरेट करें
[CODE BLOCK]
अगले कदम
- API Overview — सभी एंडपॉइंट समूह
- त्रुटियाँ और त्रुटि प्रबंधन

────────────────────────────────────────────────────────────
# User और Minds API
SUMMARY: खाता प्रबंधन — पंजीकरण, लॉगिन, minds बनाएँ, minds की सूची बनाएँ, minds हटाएँ। JWT-सुरक्षित।

KEY CONTEXT:
Auth: JWT (from /register or /login)
Register: POST /register { email, password, display_name? } → returns JWT
Login: POST /login { email, password } → returns JWT
Create mind: POST /minds { name, description? } → returns mind_key (shown once!)
List minds: GET /minds
Delete mind: DELETE /minds/:id (irreversible — deletes all memories!)
JWT expires after 7 days. Mind Key never expires.
Mind Key is shown only once at creation — save it permanently.

User और Minds API
User और Minds API खाता प्रबंधन को संभालता है। ये एंडपॉइंट्स JWT प्रमाणीकरण का उपयोग करते हैं (Mind Key नहीं) क्योंकि ये mind स्तर पर नहीं, बल्कि खाता स्तर पर काम करते हैं।
प्रमाणीकरण एंडपॉइंट्स
POST /register
नया उपयोगकर्ता खाता बनाएँ।
[CODE BLOCK]
प्रतिक्रिया:
[CODE BLOCK]
POST /login
मौजूदा खाते में लॉगिन करें।
[CODE BLOCK]
प्रतिक्रिया:  के समान।
Minds एंडपॉइंट्स
POST /minds
नया mind बनाएँ। Mind Key लौटाता है — इसे तुरंत सहेजें, यह केवल एक बार दिखाया जाता है।
[CODE BLOCK]
प्रतिक्रिया:
[CODE BLOCK]
> [!CRITICAL]
>  केवल एक बार दिखाया जाता है। यदि आप इसे खो देते हैं, तो आप इसे पुनः प्राप्त नहीं कर सकते — आपको mind हटाकर नया बनाना होगा (जिससे सभी स्टोर की गई मेमोरीज़ खो जाती हैं)।
GET /minds
वर्तमान उपयोगकर्ता के लिए सभी minds की सूची बनाएँ।
[CODE BLOCK]
प्रतिक्रिया:
[CODE BLOCK]
DELETE /minds/:id
Mind को स्थायी रूप से हटाएँ।
[CODE BLOCK]
> [!WARNING]
> Mind हटाना अपरिवर्तनीय है। उस mind में सभी मेमोरीज़, कार्य, चैट इतिहास, और स्क्रिप्ट्स स्थायी रूप से खो जाते हैं। यदि आपको बैकअप चाहिए तो पहले  के माध्यम से निर्यात करें।
मल्टी-Mind पैटर्न
अधिकांश उपयोगकर्ता संदर्भों को अलग रखने के लिए कई minds से लाभान्वित होते हैं:
[CODE BLOCK]
संदर्भों को अलग रखने के लिए विभिन्न LLM सत्रों में विभिन्न Mind Keys का उपयोग करें।
खाता सुरक्षा
पासवर्ड आवश्यकताएँ
- न्यूनतम 6 अक्षर
- कोई अधिकतम नहीं (पासवर्ड मैनेजर का उपयोग करें)
- bcrypt हैश के रूप में संग्रहीत (कभी सादा टेक्स्ट नहीं)
JWT समाप्ति
JWT 7 दिनों के बाद समाप्त हो जाते हैं। समाप्त होने पर, बस  फिर से कॉल करें।
Mind Key सुरक्षा
Mind Keys कभी समाप्त नहीं होते। यदि कोई Mind Key समझौता हो जाता है:
1.  के माध्यम से नया mind बनाएँ
2. नए Mind Key के साथ अपना LLM config अपडेट करें
3.  के माध्यम से समझौता किए गए mind को हटाएँ
अगले कदम
- प्रमाणीकरण — पूर्ण प्रमाणीकरण गाइड
- Mind Key vs JWT — निर्णय गाइड
- Sharing API — अन्य उपयोगकर्ताओं के साथ minds साझा करें

────────────────────────────────────────────────────────────
# Variables API
SUMMARY: LLM स्थिति के लिए तीव्र key-value स्टोर — काउंटर, फ़्लैग्स, अंतिम-देखा टाइमस्टैम्प्स, आंशिक प्रगति।

KEY CONTEXT:
Auth: Mind Key
Set: POST /var { key, value }
Get: GET /var/:key
List: GET /var
Delete: DELETE /var/:key
Use case: store last-seen timestamps, counters, flags, partial workflow state
Faster than memory (PostgreSQL direct, no FTS5 indexing)
Not for: structured facts (use /memory), long content (use /script)

Variables API
Variables API क्षणिक स्थिति के लिए एक तीव्र key-value स्टोर है। मेमोरीज़ (जो अनुक्रमित, खोज योग्य, और संरचित हैं) के विपरीत, वेरिएबल्स त्वरित पढ़ने/लिखने के एक्सेस के लिए अनुकूलित हैं — काउंटर, फ़्लैग्स, और सत्र स्थिति के लिए आदर्श।
एंडपॉइंट्स
POST /var
वेरिएबल सेट करें या अपडेट करें।
[CODE BLOCK]
GET /var/:key
एकल वेरिएबल प्राप्त करें।
[CODE BLOCK]
प्रतिक्रिया:
[CODE BLOCK]
GET /var
सभी वेरिएबल्स की सूची बनाएँ।
[CODE BLOCK]
DELETE /var/:key
वेरिएबल हटाएँ।
[CODE BLOCK]
वेरिएबल्स कब उपयोग करें बनाम मेमोरी
| उपयोग का मामला | उपयोग करें |
|----------|-----|
| उपयोगकर्ता नाम, प्राथमिकताएँ | Memory (खोज योग्य, संरचित) |
| अंतिम सत्र टाइमस्टैम्प | Variable (क्षणिक स्थिति) |
| काउंटर (जैसे भेजे गए संदेश) | Variable (अक्सर अपडेट) |
| वर्कफ़्लो स्थिति ("5 में से 3 चरण पूर्ण") | Variable (क्षणिक) |
| लंबी-प्रपत्र परियोजना नोट्स | Memory (फुल-टेक्स्ट अनुक्रमित) |
| पुनः प्रयोज्य स्क्रिप्ट्स | Script store (नामित, संस्करणित) |
सामान्य पैटर्न
अंतिम सत्र ट्रैक करें
[CODE BLOCK]
काउंटर पैटर्न
[CODE BLOCK]
फ़ीचर फ़्लैग्स
[CODE BLOCK]
अगले कदम
- Memory API — संरचित, खोज योग्य डेटा के लिए
- Cron और Scheduler

────────────────────────────────────────────────────────────
# Webhooks API
SUMMARY: मेमोरी, चैट, और कार्य घटनाओं के लिए HTTP कॉलबैक पंजीकृत करें — डेटा बदलने पर सूचित हों।

KEY CONTEXT:
Auth: Mind Key
Register: POST /webhooks { url, events, secret? }
List: GET /webhooks
Get: GET /webhooks/:id
Update: PUT /webhooks/:id { url?, events?, secret?, enabled? }
Delete: DELETE /webhooks/:id
Events: memory.*, memory.store, memory.update, memory.delete, chat.*, chat.message_received, task.*, task.created, task.completed
Secret: HMAC-SHA256 signed payload, sent in X-Synapse-Signature header
Pattern: register webhook → receive POST → process event → call Synapse API

Webhooks API
Webhooks आपको Synapse में घटनाएँ होने पर HTTP कॉलबैक प्राप्त करने की सुविधा देते हैं। बाहरी ऑटोमेशन ट्रिगर करने, सूचनाएँ भेजने, या अन्य सिस्टम्स में सिंक करने के लिए आदर्श।
एंडपॉइंट्स
POST /webhooks
नया webhook पंजीकृत करें।
[CODE BLOCK]
प्रतिक्रिया:
[CODE BLOCK]
GET /webhooks
वर्तमान mind के लिए सभी webhooks की सूची बनाएँ।
[CODE BLOCK]
GET /webhooks/:id
एकल webhook प्राप्त करें।
[CODE BLOCK]
PUT /webhooks/:id
Webhook अपडेट करें (URL, events, secret, या enabled फ़्लैग)।
[CODE BLOCK]
DELETE /webhooks/:id
Webhook हटाएँ।
[CODE BLOCK]
घटना प्रकार
| पैटर्न | कब सक्रिय होता है |
|---------|------------|
|  | कोई भी मेमोरी घटना |
|  | नई मेमोरी स्टोर की गई |
|  | मेमोरी अपडेट की गई |
|  | मेमोरी हटाई गई |
|  | कोई भी चैट घटना |
|  | मानव से नया संदेश |
|  | कोई भी कार्य घटना |
|  | नया कार्य बनाया गया |
|  | कार्य पूर्ण चिह्नित किया गया |
|  | सभी घटनाएँ |
Webhook Payload
जब कोई घटना सक्रिय होती है, Synapse आपके URL पर POST करता है:
[CODE BLOCK]
हस्ताक्षर सत्यापन
यदि आप  सेट करते हैं, तो Synapse प्रत्येक payload को HMAC-SHA256 के साथ हस्ताक्षरित करता है:
[CODE BLOCK]
अपने हैंडलर में सत्यापित करें:
[CODE BLOCK]
पैटर्न: रियल-टाइम सिंक
[CODE BLOCK]
अगले कदम
- Cron और Scheduler
- Webhook ऑटोमेशन गाइड

## श्रेणी: MCP एकीकरण
Claude, Cursor और अन्य MCP क्लाइंट के साथ एकीकरण।

────────────────────────────────────────────────────────────
# Claude Code में MCP
SUMMARY: Claude Code टर्मिनल एजेंट से Synapse टूल का उपयोग करें — कोडिंग सत्रों के लिए परसिस्टेंट मेमोरी।

KEY CONTEXT:
Claude Code config: ~/.claude/config.json (or via `claude mcp add` command)
Command: npx -y synapse-mcp-api@latest
Env: SYNAPSE_MIND_KEY (required), SYNAPSE_URL (optional)
Alternative: `claude mcp add synapse -- npx -y synapse-mcp-api@latest`
Then: set SYNAPSE_MIND_KEY env var in your shell
Test: in claude code, type "recall all my memories"

Claude Code में MCP
Claude Code Anthropic का टर्मिनल-आधारित कोडिंग एजेंट है। Synapse MCP के साथ,
Claude Code कोडिंग सत्रों में परसिस्टेंट मेमोरी प्राप्त करता है — यह आपका
प्रोजेक्ट संदर्भ, पिछले निर्णय और कोडबेस पैटर्न याद रखता है।
सेटअप
विधि 1: CLI कमांड (अनुशंसित)
[CODE BLOCK]
विधि 2: कॉन्फ़िग फ़ाइल एडिट करें
 एडिट करें:
[CODE BLOCK]
सत्यापित करें कि यह काम करता है
Claude Code शुरू करें:
[CODE BLOCK]
Claude Code प्रॉम्प्ट में टाइप करें:
[CODE BLOCK]
Claude को  कॉल करना चाहिए और आपकी संग्रहीत मेमोरीज़ के साथ प्रतिक्रिया देनी चाहिए।
सामान्य पैटर्न
प्रोजेक्ट संदर्भ परसिस्टेंस
कोडिंग सत्र की शुरुआत में:
[CODE BLOCK]
Claude  कॉल करता है, आपकी प्रोजेक्ट सूची देखता है, और जहाँ छोड़ा था वहाँ काम जारी रखता है।
कोडबेस निर्णय
जब आप कोई आर्किटेक्चरल निर्णय लेते हैं:
[CODE BLOCK]
Claude  को  श्रेणी,  प्राथमिकता के साथ कॉल करता है।
पिछली गलतियों से बचना
[CODE BLOCK]
Claude  श्रेणी वाली मेमोरीज़ खोजता है और आपको पिछली त्रुटियों के बारे में याद दिलाता है।
कार्य ट्रैकिंग
[CODE BLOCK]
Claude  कॉल करता है, और कार्य सत्रों में परसिस्ट होता है।
टूल प्रोफाइल
उन कोडिंग सत्रों के लिए जहाँ आपको सभी 119 टूल की आवश्यकता नहीं:
[CODE BLOCK]
समस्या निवारण
MCP server शुरू नहीं हो रहा
[CODE BLOCK]
Mind Key पहचाना नहीं जा रहा
[CODE BLOCK]
Claude Code टूल नहीं देख रहा
- कॉन्फ़िग परिवर्तनों के बाद Claude Code पुनः आरंभ करें
- यह सत्यापित करने के लिए  जाँचें कि Synapse रजिस्टर है
- MCP Troubleshooting देखें
अगले कदम
- Claude Desktop Setup
- Cursor Setup
- Persistent LLM Agent Guide

────────────────────────────────────────────────────────────
# Claude Desktop में MCP
SUMMARY: Synapse को Claude Desktop से 2 मिनट में कनेक्ट करें। Claude को नेटिव रूप से 79 Synapse टूल मिलते हैं।

KEY CONTEXT:
Config file: ~/Library/Application Support/Claude/claude_desktop_config.json (macOS)
             %APPDATA%\Claude\claude_desktop_config.json (Windows)
MCP server command: npx -y synapse-mcp-api@latest
Env vars: SYNAPSE_MIND_KEY (required), SYNAPSE_URL (optional, default https://synapse.schaefer.zone)
After config: restart Claude Desktop, check for 🔌 icon with "79 tools"
Test: type "memory_recall aufrufen" in a new chat
Troubleshooting: Node.js ≥ 18, check Mind Key, see /docs/mcp/troubleshooting

Claude Desktop में MCP
Claude Desktop Anthropic का macOS और Windows के लिए डेस्कटॉप ऐप है। Synapse
MCP server कॉन्फ़िगर करने के साथ, Claude सभी 79 Synapse टूल तक नेटिव पहुँच प्राप्त
करता है — यह मेमोरीज़ स्टोर कर सकता है, उन्हें रिकॉल कर सकता है, कार्य प्रबंधित कर सकता
है, आपसे चैट कर सकता है, और बहुत कुछ।
पूर्वापेक्षाएँ
- Claude Desktop ऐप (macOS या Windows)
- Node.js 18+ इंस्टॉल ()
- आपकी Synapse Mind Key
चरण 1: कॉन्फ़िग फ़ाइल खोलें
- macOS: 
- Windows: 
यदि फ़ाइल मौजूद नहीं है, तो इसे बनाएँ।
चरण 2: Synapse MCP Server जोड़ें
[CODE BLOCK]
> [!TIP]
> यदि आपके पास पहले से अन्य MCP servers कॉन्फ़िगर हैं, तो बस 
> ब्लॉक को मौजूदा  ऑब्जेक्ट के अंदर जोड़ें।
चरण 3: Claude Desktop पुनः आरंभ करें
1. Claude Desktop पूरी तरह से बंद करें (macOS पर Cmd+Q, केवल विंडो बंद न करें)
2. Claude Desktop फिर से खोलें
3. नई चैट शुरू करें
4. नीचे-बाएँ 🔌 प्लग आइकन की तलाश करें — इसमें "79 tools" लिखा होना चाहिए
चरण 4: इसे टेस्ट करें
नई चैट में टाइप करें:
[CODE BLOCK]
Claude को  टूल कॉल करना चाहिए और आपकी संग्रहीत मेमोरीज़ के साथ सारांश के साथ प्रतिक्रिया देनी चाहिए (या यदि आपका mind खाली है तो "No memories yet")।
उपलब्ध टूल (चयन)
| टूल | विवरण |
|------|-------------|
|  | सभी मेमोरीज़ रिकॉल करें |
|  | नई मेमोरी स्टोर करें |
|  | मेमोरीज़ खोजें |
|  | कार्य सूचीबद्ध करें |
|  | कार्य बनाएँ |
|  | नए संदेशों की जाँच करें |
|  | संदेश का उत्तर दें |
|  | ब्राउज़र टैब खोलें |
|  | पंजीकृत कंप्यूटर सूचीबद्ध करें |
पूरी सूची: What is MCP?
समस्या निवारण
Claude Desktop में कोई टूल दिखाई नहीं देता
1. Node.js संस्करण सत्यापित करें:  (≥ 18 होना चाहिए)
2. जाँचें कि कॉन्फ़िग फ़ाइल वैध JSON है (कोई ट्रेलिंग कॉमा नहीं)
3. Claude Desktop पूरी तरह पुनः आरंभ करें (Cmd+Q, केवल बंद नहीं)
4. Claude Desktop लॉग जाँचें:  (macOS)
"Mind Key invalid" त्रुटि
- सत्यापित करें कि   से शुरू होता है
-  के माध्यम से नई कुंजी प्राप्त करें ( से JWT की आवश्यकता)
- JSON में कुंजी के चारों ओर कोई उद्धरण नहीं
npx नहीं मिला
- Node.js 18+ इंस्टॉल करें: <https://nodejs.org/>
- इंस्टॉल के बाद टर्मिनल पुनः आरंभ करें
- Homebrew के साथ macOS पर: 
टूल दिखाई देते हैं लेकिन कॉल विफल होते हैं
- जाँचें कि  पहुँच योग्य है: 
- सत्यापित करें कि आपकी Mind Key काम करती है: 
- MCP Troubleshooting देखें
टूल प्रोफाइल (टोकन बचाएँ)
यदि आप किसी छोटे LLM का उपयोग कर रहे हैं या संदर्भ टोकन बचाना चाहते हैं, तो टूल प्रोफाइल सेट करें:
[CODE BLOCK]
प्रोफाइल:  (8 टूल),  (25),  (119, डिफ़ॉल्ट)।
अगले कदम
- Claude Code Setup
- Cursor Setup
- MCP Troubleshooting

────────────────────────────────────────────────────────────
# Continue.dev में MCP
SUMMARY: Synapse को Continue.dev से कनेक्ट करें — VS Code और JetBrains के लिए ओपन-सोर्स AI कोडिंग सहायक।

Continue.dev में MCP
Continue.dev VS Code और JetBrains IDEs के लिए एक ओपन-सोर्स AI कोडिंग सहायक है। Synapse MCP के साथ, Continue सत्रों में परसिस्टेंट मेमोरी प्राप्त करता है।
पूर्वापेक्षाएँ
- VS Code या JetBrains IDE
- Continue.dev एक्सटेंशन इंस्टॉल
- Node.js 18+
- आपकी Synapse Mind Key
सेटअप
चरण 1: Continue कॉन्फ़िग खोलें
VS Code या JetBrains में:
1. Continue एक्सटेंशन साइडबार खोलें
2. गियर आइकन पर क्लिक करें → "Open config.json"
या सीधे  एडिट करें।
चरण 2: Synapse MCP Server जोड़ें
[CODE BLOCK]
चरण 3: Continue रीलोड करें
VS Code विंडो रीलोड करें (Cmd+Shift+P → "Reload Window") या अपना IDE पुनः आरंभ करें।
सत्यापित करें कि यह काम करता है
Continue चैट में:
[CODE BLOCK]
Continue को  कॉल करना चाहिए और आपकी संग्रहीत मेमोरीज़ के साथ प्रतिक्रिया देनी चाहिए।
सामान्य पैटर्न
प्रोजेक्ट संदर्भ
[CODE BLOCK]
Continue  कॉल करता है, आपकी प्रोजेक्ट मेमोरीज़ देखता है, और जहाँ छोड़ा था वहाँ काम जारी रखता है।
कोड समीक्षा पैटर्न
[CODE BLOCK]
Continue आपकी संग्रहीत कोड समीक्षा पैटर्न ढूँढता है और उन्हें लागू करता है।
पेयर प्रोग्रामिंग मेमोरी
[CODE BLOCK]
Continue इसे  मेमोरी के रूप में स्टोर करता है।
समस्या निवारण
MCP server कनेक्ट नहीं हो रहा
1. जाँचें कि  वैध JSON है
2. Node.js सत्यापित करें: 
3. Continue के आउटपुट पैनल की जाँच करें (View → Output → Continue)
4. IDE पुनः आरंभ करें
टूल दिखाई नहीं दे रहे
- सत्यापित करें कि Continue संस्करण MCP का समर्थन करता है (≥ 0.9.x)
- जाँचें कि कॉन्फ़िग में  env var सेट है
- Continue के लॉग में MCP त्रुटियाँ देखें
अगले कदम
- Claude Desktop Setup
- Custom MCP Client

────────────────────────────────────────────────────────────
# Cursor में MCP
SUMMARY: Cursor IDE से Synapse को कनेक्ट करें — कोडिंग सत्रों में परसिस्टेंट प्रोजेक्ट मेमोरी के लिए।

Cursor में MCP
Cursor VS Code पर आधारित AI-संचालित IDE है। Synapse MCP के साथ, Cursor सत्रों
में परसिस्टेंट मेमोरी प्राप्त करता है — यह आपके प्रोजेक्ट निर्णय, कोडबेस
पैटर्न और पिछले डिबगिंग सत्र याद रखता है।
पूर्वापेक्षाएँ
- Cursor IDE इंस्टॉल (<https://cursor.com>)
- Node.js 18+
- आपकी Synapse Mind Key
सेटअप
चरण 1: Cursor सेटिंग्स खोलें
Cursor में:
1. Settings खोलें (macOS पर Cmd+, Windows/Linux पर Ctrl+,)
2. "MCP" खोजें या  पर जाएँ
चरण 2: Synapse MCP Server जोड़ें
"Add MCP Server" पर क्लिक करें और कॉन्फ़िगर करें:
| फ़ील्ड | मान |
|-------|-------|
| Name |  |
| Type |  |
| Command |  |
| Env |  |
चरण 3: config.json सीधे एडिट करें (वैकल्पिक)
Cursor MCP कॉन्फ़िग  में स्टोर करता है:
[CODE BLOCK]
चरण 4: Cursor पुनः आरंभ करें
Cursor पूरी तरह पुनः आरंभ करें (macOS पर Cmd+Q और फिर से खोलें)।
सत्यापित करें कि यह काम करता है
Cursor के चैट पैनल में (Cmd+L):
[CODE BLOCK]
Cursor को  कॉल करना चाहिए और आपकी संग्रहीत मेमोरीज़ के साथ प्रतिक्रिया देनी चाहिए।
सामान्य पैटर्न
प्रोजेक्ट ऑनबोर्डिंग
नया प्रोजेक्ट खोलते समय:
[CODE BLOCK]
Cursor  कॉल करता है और जहाँ छोड़ा था वहाँ काम जारी रखता है।
आर्किटेक्चर निर्णय
[CODE BLOCK]
Cursor इसे  प्राथमिकता के साथ  मेमोरी के रूप में स्टोर करता है।
डिबगिंग इतिहास
[CODE BLOCK]
Cursor  मेमोरीज़ खोजता है और पिछले सुधारों के बारे में याद दिलाता है।
क्रॉस-सत्र कोड पैटर्न
[CODE BLOCK]
Cursor आपके द्वारा पहले किए गए auth कार्यान्वयन के बारे में मेमोरीज़ ढूँढता है।
समस्या निवारण
MCP server कनेक्ट नहीं हो रहा
1. Node.js सत्यापित करें:  (≥ 18)
2. MCP server टेस्ट करें:  (बिना त्रुटि के शुरू होना चाहिए)
3. Cursor के MCP लॉग जाँचें (View → Output → MCP)
4. Cursor पूरी तरह पुनः आरंभ करें
टूल दिखाई नहीं दे रहे
- जाँचें कि  वैध JSON है
- सत्यापित करें कि  env var सेट है
- जाँचें कि Cursor संस्करण MCP का समर्थन करता है (≥ 0.42)
Mind Key अमान्य
[CODE BLOCK]
अगले कदम
- Claude Desktop Setup
- Continue.dev Setup
- Persistent LLM Agent Guide

────────────────────────────────────────────────────────────
# कस्टम MCP Client बनाएँ
SUMMARY: MCP SDK का उपयोग करके अपने एप्लिकेशन से Synapse MCP server से कनेक्ट करें।

कस्टम MCP Client बनाएँ
यदि आप अपना स्वयं का LLM एप्लिकेशन बना रहे हैं, तो आप आधिकारिक MCP SDK का उपयोग करके सीधे Synapse MCP server से कनेक्ट कर सकते हैं। इससे आपके ऐप को सभी 79 Synapse टूल तक पहुँच मिलती है।
SDKs
| भाषा | पैकेज |
|----------|---------|
| TypeScript/JavaScript |  |
| Python |  |
TypeScript उदाहरण
इंस्टॉल करें
[CODE BLOCK]
stdio के माध्यम से कनेक्ट करें
[CODE BLOCK]
HTTP/SSE के माध्यम से कनेक्ट करें (रिमोट)
[CODE BLOCK]
Python उदाहरण
इंस्टॉल करें
[CODE BLOCK]
stdio के माध्यम से कनेक्ट करें
[CODE BLOCK]
टूल प्रोफाइल
कनेक्ट करते समय, आप  हेडर (HTTP/SSE) या  env var (stdio) के माध्यम से विशिष्ट टूल प्रोफाइल का अनुरोध कर सकते हैं:
[CODE BLOCK]
त्रुटि हैंडलिंग
[CODE BLOCK]
उपयोग के मामले
- कस्टम AI सहायक — परसिस्टेंट मेमोरी के साथ अपना स्वयं का एजेंट बनाएँ
- वर्कफ़्लो स्वचालन — कस्टम वर्कफ़्लो में Synapse टूल चेन करें
- डेटा पाइपलाइन — मेमोरीज़ निकालें, ट्रांसफ़ॉर्म करें, कहीं और लोड करें
- मॉनिटरिंग डैशबोर्ड — मेमोरी आँकड़े, चैट इतिहास, कार्य प्रदर्शित करें
अगले कदम
- MCP Specification
- Synapse MCP Repo
- API Overview

────────────────────────────────────────────────────────────
# MCP समस्या निवारण
SUMMARY: सामान्य MCP एकीकरण समस्याओं को हल करें — server शुरू नहीं हो रहा, टूल दिखाई नहीं दे रहे, auth त्रुटियाँ।

KEY CONTEXT:
Common issues:
1. Node.js < 18 → upgrade to 18+
2. Mind Key invalid → check format (mk_...), get fresh via POST /minds
3. npx not found → install Node.js
4. Tools not appearing → restart client, check config JSON validity
5. SYNAPSE_URL unreachable → curl /health to verify
6. MCP server crashes → check logs, run npx manually to see error
Debug steps: run `npx -y synapse-mcp-api@latest` manually, check stderr
Logs: Claude Desktop ~/Library/Logs/Claude/mcp.log, Cursor ~/.cursor/logs/

MCP समस्या निवारण
Synapse MCP को अपने LLM client के साथ एकीकृत करते समय सामान्य समस्याएँ और समाधान।
त्वरित डायग्नोस्टिक चेकलिस्ट
1. ✅ Node.js 18+ इंस्टॉल है? ()
2. ✅ Mind Key  से शुरू होती है? (JWT  नहीं)
3. ✅ Synapse API पहुँच योग्य है? ()
4. ✅ Mind Key काम करती है? ()
5. ✅ कॉन्फ़िग फ़ाइल वैध JSON है? (कोई ट्रेलिंग कॉमा नहीं, कोई टिप्पणी नहीं)
6. ✅ कॉन्फ़िग परिवर्तन के बाद client पुनः आरंभ किया?
7. ✅ MCP server मैन्युअली शुरू होता है? ()
समस्या: Client में कोई टूल दिखाई नहीं देता
लक्षण
- Claude Desktop / Cursor / Continue 0 टूल दिखाता है
- MCP servers सूची में कोई 🔌 आइकन या "synapse" एंट्री नहीं
समाधान
1. Client पूरी तरह पुनः आरंभ करें — macOS पर Cmd+Q (केवल विंडो बंद न करें)
2. कॉन्फ़िग फ़ाइल स्थान जाँचें:
   - Claude Desktop macOS: 
   - Claude Desktop Windows: 
   - Cursor: 
   - Continue: 
3. JSON को मान्य करें — कॉन्फ़िग को <https://jsonlint.com> में पेस्ट करें
4. MCP त्रुटियों के लिए client लॉग जाँचें:
   - Claude Desktop:  (macOS)
   - Cursor: View → Output → MCP
5. स्टार्टअप त्रुटियाँ देखने के लिए MCP server मैन्युअली चलाएँ:
   [CODE BLOCK]
समस्या: "Mind Key invalid" त्रुटि
लक्षण
- टूल दिखाई देते हैं लेकिन कॉल "401 Unauthorized" के साथ विफल होते हैं
- त्रुटि: "Mind Key fehlt oder ungültig"
समाधान
1. Mind Key प्रारूप सत्यापित करें —  से शुरू, 40 अक्षर
2. सीधे टेस्ट करें:
   [CODE BLOCK]
3. जाँचें कि env var सेट है — stdio ट्रांसपोर्ट के लिए, env var आपके शेल में नहीं, MCP server कॉन्फ़िग में होना चाहिए
4. नई Mind Key प्राप्त करें:
   [CODE BLOCK]
समस्या: npx नहीं मिला
लक्षण
- त्रुटि: "npx: command not found"
- MCP server शुरू होने में विफल
समाधान
1. Node.js 18+ इंस्टॉल करें:
   - macOS:  या <https://nodejs.org> से डाउनलोड करें
   - Linux: 
   - Windows: <https://nodejs.org> से डाउनलोड करें
2. इंस्टॉल के बाद टर्मिनल पुनः आरंभ करें
3. सत्यापित करें: 
समस्या: SYNAPSEURL पहुँच योग्य नहीं
लक्षण
- MCP server शुरू होता है लेकिन टूल कॉल टाइमआउट हो जाते हैं
- त्रुटि: "fetch failed" या "ECONNREFUSED"
समाधान
1. कनेक्टिविटी टेस्ट करें:
   [CODE BLOCK]
2. कॉर्पोरेट फ़ायरवॉल जाँचें — आउटबाउंड HTTPS को ब्लॉक कर सकता है
3. वैकल्पिक URL आज़माएँ:
   - Production: 
   - MCP server: 
4. सेल्फ-होस्टेड के लिए: सुनिश्चित करें कि आपका Synapse इंस्टेंस चल रहा है और पहुँच योग्य है
समस्या: MCP Server क्रैश
लक्षण
- MCP server शुरू होने के तुरंत बाद बाहर निकलता है
- Client लॉग "MCP server disconnected" दिखाते हैं
समाधान
1. त्रुटि देखने के लिए मैन्युअली चलाएँ:
   [CODE BLOCK]
2. पोर्ट संघर्ष की जाँच करें — MCP server डिफ़ॉल्ट रूप से पोर्ट 13100 का उपयोग करता है
3. npx कैश साफ़ करें:
   [CODE BLOCK]
4. नवीनतम में अपडेट करें:
   [CODE BLOCK]
समस्या: टूल कॉल 429 लौटाते हैं
लक्षण
- त्रुटि: "Rate limit exceeded"
समाधान
यह MCP के साथ नहीं होना चाहिए (हेडर auth का उपयोग करता है, कोई रेट लिमिट नहीं)। यदि होता है:
1. जाँचें कि कहीं आप  का उपयोग तो नहीं कर रहे — हेडर auth पर स्विच करें
2.  सत्यापित करें — सुनिश्चित करें कि यह सही इंस्टेंस की ओर इशारा करता है
3. सहायता से संपर्क करें यदि समस्या बनी रहे
समस्या: टूल दिखाई देते हैं लेकिन काम नहीं करते
लक्षण
- Client में टूल सूचीबद्ध हैं
- टूल कॉल करने पर त्रुटि या कोई परिणाम नहीं
समाधान
1. टूल नाम जाँचें — सटीक होना चाहिए (जैसे , न कि )
2. आर्ग्युमेंट सत्यापित करें — टूल के इनपुट स्कीमा की जाँच करें
3. सीधे API के माध्यम से टेस्ट करें:
   [CODE BLOCK]
4. Synapse हेल्थ जाँचें:
   [CODE BLOCK]
सहायता प्राप्त करना
यदि उपरोक्त में से कुछ भी आपकी समस्या हल नहीं करता:
1. मौजूदा issues जाँचें: <https://gitlab.com/schaefer-services/synapse-mcp/-/issues>
2. नया issue खोलें इनके साथ:
   - MCP server संस्करण ()
   - Client नाम और संस्करण
   - ऑपरेटिंग सिस्टम
   - संबंधित लॉग अंश
   - पुनः उत्पन्न करने के चरण
अगले कदम
- Claude Desktop Setup
- Claude Code Setup
- API Errors

────────────────────────────────────────────────────────────
# MCP क्या है?
SUMMARY: Model Context Protocol LLMs को बाहरी टूल कॉल करने देता है। Synapse आधिकारिक MCP server के माध्यम से 79 टूल उपलब्ध कराता है।

KEY CONTEXT:
MCP = Model Context Protocol (Anthropic, 2024). Open standard for LLM-tool integration.
Synapse has official MCP server: synapse-mcp-api (npm package, npx -y synapse-mcp-api@latest)
79 tools exposed: 22 memory, 7 chat, 8 scheduler, 4 tasks, 5 scripts, 9 computers, 4 push, 5 user, 3 utility
3 transports: stdio (local), HTTP/SSE (remote), WebSocket (mobile)
Supported clients: Claude Desktop, Claude Code, Cursor, Continue, Cline, any MCP-compatible client
Tool Profiles (v1.4.0): minimal (8 tools), standard (25), full (119) — controlled via MCP_PROFILE env or Mcp-Tool-Profile header

MCP क्या है?
Model Context Protocol (MCP) Anthropic (2024) द्वारा एक खुला मानक है
जो LLMs को संरचित तरीके से बाहरी टूल कॉल करने देता है। प्रॉम्प्ट में API
docs पेस्ट करने के बजाय, आप टूल को MCP server के साथ रजिस्टर करते हैं, और LLM
आवश्यकतानुसार उन्हें कॉल करता है — जैसे फ़ंक्शन कॉलिंग, लेकिन मानकीकृत और
client-अज्ञेयवादी।
Synapse MCP Server
Synapse एक आधिकारिक MCP server ( npm पर) शिप करता है जो
सभी Synapse सुविधाओं को कवर करने वाले 79 टूल उपलब्ध कराता है:
| श्रेणी | टूल | संख्या |
|----------|-------|-------|
| Memory | recall, list, store, search, semantic-search, update, delete, bulk-delete, stats, unverified, contradictions, audit, related, by-tag, diff, expiring, health, sync, embed-batch, verify, unverify, mind-export | 22 |
| Chat | poll, reply, status, history, unread, send, upload | 7 |
| Scheduler | cronlist, croncreate, crondelete, crontoggle, varlist, varget, varset, vardelete | 8 |
| Tasks | tasklist, taskget, taskcreate, taskupdate | 4 |
| Scripts | scriptlist, scriptget, scriptinfo, scriptstore, scriptdelete | 5 |
| Computers | computerlist, computerget, installcode, screenshot, commandqueue, commandstatus, commandslist, disable, delete | 9 |
| Push | vapidpublickey, subscribe, unsubscribe, test | 4 |
| User/Mind | register, login, mindslist, mindcreate, minddelete | 5 |
| Utility | time, calc, random | 3 |
| Visualization | graph, tags, compact | 3 |
| Sharing | share, list, revoke | 3 |
| Webhooks | register, list, get, update, delete | 5 |
| Browser | new, navigate, click, type, screenshot, close | 6 |
| कुल | | 79+ |
यह कैसे काम करता है
[CODE BLOCK]
1. आप अपने LLM client (Claude Desktop, Cursor, आदि) को Synapse MCP server का उपयोग करने के लिए कॉन्फ़िगर करते हैं
2. Client MCP server शुरू करता है ( के माध्यम से)
3. MCP server आपकी Mind Key का उपयोग करके Synapse API से कनेक्ट होता है
4. LLM सभी 79 टूल को नेटिव फ़ंक्शन के रूप में देखता है जिन्हें वह कॉल कर सकता है
5. जब LLM को कुछ याद रखना होता है, तो वह  कॉल करता है — MCP server इसे Synapse पर  में अनुवाद करता है
ट्रांसपोर्ट
Synapse MCP server तीन ट्रांसपोर्ट का समर्थन करता है:
stdio (स्थानीय, डेस्कटॉप के लिए अनुशंसित)
[CODE BLOCK]
HTTP/SSE (रिमोट, मल्टी-टैनेंट)
अपने MCP client को कनेक्ट करें:
[CODE BLOCK]
WebSocket (मोबाइल, उच्च-मात्रा)
[CODE BLOCK]
टूल प्रोफाइल (v1.4.0)
छोटे LLMs के लिए टोकन ओवरहेड कम करने के लिए, MCP server तीन
टूल प्रोफाइल का समर्थन करता है:
| प्रोफाइल | टूल | टोकन | के लिए सर्वोत्तम |
|---------|-------|--------|----------|
|  | 8 (कंपोज़िट डिस्पैच) | 500 | ≤8k संदर्भ वाले सेल्फ-होस्टेड LLMs |
|  | 25 (नामित) | 2,500 | मध्यम-आकार के LLMs (Claude Haiku, GPT-3.5) |
|  | 119 (सभी) | 8,250 | बड़े LLMs (Claude Sonnet/Opus, GPT-4) — डिफ़ॉल्ट |
नियंत्रण:
- Env var: 
- Header: 
समर्थित Clients
- Claude Desktop — Anthropic का डेस्कटॉप ऐप
- Claude Code — टर्मिनल कोडिंग एजेंट
- Cursor — AI-संचालित IDE
- Continue.dev — ओपन-सोर्स AI कोडिंग सहायक
- Cline — VS Code एक्सटेंशन
- कोई भी MCP-संगत client
सीधे API के बजाय MCP का उपयोग क्यों?
| दृष्टिकोण | फायदे | नुकसान |
|----------|------|------|
| सीधे API | सरल, कोई अतिरिक्त परत नहीं | LLM को URLs, headers, auth जानना होगा |
| MCP | LLM नेटिव टूल देखता है, कोई URL याद रखना नहीं | अतिरिक्त MCP server प्रक्रिया |
अधिकांश LLM एजेंट उपयोग के मामलों के लिए, MCP बेहतर विकल्प है — LLM को
API पथ या auth पैटर्न याद रखने की आवश्यकता नहीं।
अगले कदम
- Claude Desktop Setup — 2-मिनट कॉन्फ़िग
- Claude Code Setup — टर्मिनल एकीकरण
- Custom MCP Client — अपना खुद का बनाएँ

## श्रेणी: गाइड और कैसे-करें
ठोस परिदृश्यों के लिए चरण-दर-चरण मार्गदर्शिका।

────────────────────────────────────────────────────────────
# स्वचालित iOS ऐप परीक्षण
SUMMARY: Synapse + Computer Control API का उपयोग Simulator के माध्यम से iOS ऐप परीक्षण स्वचालित करने के लिए।

स्वचालित iOS ऐप परीक्षण
LLM-चालित iOS ऐप परीक्षण बनाने के लिए Synapse की मेमोरी प्रणाली को Computer Control API के साथ जोड़ें। LLM परीक्षण परिदृश्यों को याद रखता है, पिछली विफलताओं से सीखता है, और UI परिवर्तनों के अनुसार ढल जाता है।
आर्किटेक्चर
[CODE BLOCK]
पूर्वापेक्षाएँ
- Synapse खाता + Mind Key
- Claude Desktop में Synapse MCP server कॉन्फ़िगर किया गया
-  इंस्टॉल के साथ iOS Simulator
- Synapse में पंजीकृत कंप्यूटर (Computer Control API देखें)
चरण 1: Simulator कंप्यूटर पंजीकृत करें
iOS Simulator चलाने वाले Mac पर:
[CODE BLOCK]
चरण 2: मेमोरी में परीक्षण परिदृश्य स्टोर करें
पुनः प्रयोज्य परीक्षण परिदृश्यों को मेमोरीज़ के रूप में स्टोर करें:
[CODE BLOCK]
चरण 3: LLM-चालित परीक्षण निष्पादन
Claude Desktop में (Synapse MCP कॉन्फ़िगर के साथ):
[CODE BLOCK]
Claude करेगा:
1.  मेमोरी खोजने के लिए  कॉल करेगा
2. वर्तमान स्थिति देखने के लिए  कॉल करेगा
3. प्रत्येक चरण को  (click, type) के माध्यम से निष्पादित करेगा
4. स्क्रीनशॉट के माध्यम से परिणाम सत्यापित करेगा
5. किसी भी विफलताओं को  मेमोरीज़ के रूप में स्टोर करेगा
चरण 4: स्व-उपचार परीक्षण
जब कोई परीक्षण विफल हो, तो विफलता और उपचार स्टोर करें:
[CODE BLOCK]
अगली बार LLM परीक्षण चलाने पर, यह विफलता को रिकॉल करता है और उपचार स्वचालित रूप से लागू करता है।
चरण 5: परीक्षण परिणाम ट्रैकिंग
परीक्षण रन को कार्य के रूप में ट्रैक करें:
[CODE BLOCK]
सामान्य कमांड्स
| क्रिया | कमांड |
|--------|---------|
| Simulator लॉन्च करें |  |
| स्क्रीनशॉट |  (Synapse MCP के माध्यम से) |
| (x,y) पर टैप |  |
| टेक्स्ट टाइप करें |  |
| Home दबाएँ |  |
सर्वोत्तम प्रथाएँ
> [!TIP]
> - UI निर्देशांकों को मेमोरीज़ के रूप में स्टोर करें — UI बदलता है, लेकिन LLM फिर से सीख सकता है
> - accessibility लेबल का उपयोग करें — निर्देशांकों से अधिक स्थिर
> - परीक्षण डेटा अलग रखें — उपयोगकर्ता नाम, पासवर्ड के लिए variables का उपयोग करें
> - स्वच्छ स्थिति में परीक्षण चलाएँ — रन के बीच Simulator रीसेट करें
> - विफलताओं के लिए स्क्रीनशॉट लॉग करें — डीबगिंग के लिए उपयोगी
अगले कदम
- स्व-उपचार परीक्षण
- Computer Control API
- मेमोरी सर्वोत्तम प्रथाएँ

────────────────────────────────────────────────────────────
# बैकअप और रिस्टोर
SUMMARY: बैकअप के लिए अपनी मेमोरीज़ निर्यात करें, minds के बीच माइग्रेट करें, डेटा हानि के बाद रिस्टोर करें।

बैकअप और रिस्टोर
Synapse मेमोरी बैकअप, माइग्रेशन, और आपदा पुनर्प्राप्ति के लिए पूर्ण निर्यात/आयात प्रदान करता है। यह गाइड आवश्यक ऑपरेशन्स को कवर करती है।
निर्यात
पूर्ण Mind निर्यात
एक mind में सभी मेमोरीज़ को JSON के रूप में निर्यात करें:
[CODE BLOCK]
प्रतिक्रिया प्रारूप:
[CODE BLOCK]
इंक्रीमेंटल निर्यात (Diff)
केवल किसी टाइमस्टैम्प के बाद से बदली गई मेमोरीज़ निर्यात करें:
[CODE BLOCK]
प्रतिक्रिया:
[CODE BLOCK]
स्वचालित बैकअप
cron के माध्यम से दैनिक बैकअप शेड्यूल करें:
[CODE BLOCK]
> [!NOTE]
> cron एंडपॉइंट प्रतिक्रिया प्राप्त करता है लेकिन इसे स्टोर नहीं करता। वास्तविक बैकअप के लिए, cron को अपने स्वयं के बैकअप सर्वर पर निर्देशित करें जो प्रतिक्रिया सहेजता है।
बेहतर: बाहरी बैकअप स्क्रिप्ट
[CODE BLOCK]
crontab में जोड़ें:
[CODE BLOCK]
रिस्टोर
उसी Mind में रिस्टोर करें
[CODE BLOCK]
नए Mind में रिस्टोर करें
[CODE BLOCK]
Python रिस्टोर स्क्रिप्ट
[CODE BLOCK]
Minds के बीच माइग्रेशन
[CODE BLOCK]
अन्य डेटा बैकअप
बैकअप करना न भूलें:
| डेटा प्रकार | एंडपॉइंट |
|-----------|----------|
| Memories |  |
| Tasks |  |
| Scripts |  |
| Webhooks |  |
| Cron jobs |  |
| Variables |  |
| Chat history |  |
सत्यापन
रिस्टोर के बाद, सत्यापित करें:
[CODE BLOCK]
सर्वोत्तम प्रथाएँ
> [!TIP]
> - दैनिक बैकअप — cron से स्वचालित करें
> - रिस्टोर परीक्षण — जो बैकअप आप रिस्टोर नहीं कर सकते वह बेकार है
> - कई संस्करण रखें — कम से कम 30 दिन
> - ऑफसाइट स्टोर करें — S3, Backblaze B2, आदि
> - संवेदनशील बैकअप एन्क्रिप्ट करें — मेमोरीज़ में PII हो सकती है
> - रिस्टोर प्रक्रिया दस्तावेज़ित करें — ज़रूरत पड़ने तक आप इसे भूल जाएँगे
अगले कदम
- Memory API
- Cron और Scheduler — स्वचालित बैकअप के लिए

────────────────────────────────────────────────────────────
# मेमोरी सर्वोत्तम अभ्यास
SUMMARY: प्रभावी रिकॉल के लिए मेमोरीज़ को कैसे संरचित करें — श्रेणियाँ, कुंजी, टैग, प्राथमिकताएँ।

मेमोरी सर्वोत्तम अभ्यास
आप मेमोरीज़ को जैसे संरचित करते हैं, वे उतनी ही उपयोगी होती हैं। यह गाइड श्रेणीबद्ध करने, टैग करने और प्राथमिकता देने के पैटर्न को कवर करती है ताकि LLM सही समय पर सही जानकारी को रिकॉल कर सके।
श्रेणियाँ: सबसे विशिष्ट चुनें
| श्रेणी | उपयोग | उदाहरण |
|----------|---------|---------|
|  | उपयोगकर्ता नाम, भूमिका, संपर्क जानकारी |  |
|  | पसंद, नापसंद, कार्य शैली |  |
|  | सत्यापित योग्य तथ्य |  |
|  | प्रोजेक्ट स्थिति, निर्णय |  |
|  | उपयोगकर्ता के कौशल |  |
|  | टालने योग्य पिछली त्रुटियाँ |  |
|  | सत्र-संबंधित संदर्भ |  |
|  | विविध नोट्स |  |
> [!TIP]
> संदेह होने पर, सत्यापित योग्य जानकारी के लिए  का उपयोग करें और बाकी सब के लिए  का उपयोग करें।
> अति-श्रेणीबद्ध न करें — एक भ्रमित करने वाले  से एक स्पष्ट  बेहतर है।
कुंजी: सार्थक पहचानकर्ता
 फ़ील्ड मेमोरी का पहचानकर्ता है। सार्थक, स्थिर कुंजी का उपयोग करें:
अच्छी कुंजी:
- 
- 
- 
- 
खराब कुंजी:
-  (सार्थक नहीं)
-  (वर्णनात्मक नहीं)
-  (तारीख रिकॉल में मदद नहीं करती)
कुंजी नामकरण सम्मेलन
-  (अंडरस्कोर के साथ लोअरकेस)
- श्रेणी के साथ उपसर्ग करें: , , 
- वर्णनात्मक संज्ञाओं का उपयोग करें, क्रियाओं का नहीं
- 50 अक्षरों के भीतर रखें
टैग: खोज और फ़िल्टरिंग के लिए
टैग तेज़ फ़िल्टरिंग और खोज सक्षम करते हैं। प्रत्येक मेमोरी में 2-5 टैग जोड़ें:
[CODE BLOCK]
टैग पैटर्न
- प्रोजेक्ट नाम: , , 
- विषय: , , , 
- स्थिति: , , 
- प्राथमिकता संकेतक: , 
> [!NOTE]
> टैग केस-असंवेदनशील होते हैं। सुसंगतता के लिए लोअरकेस का उपयोग करें।
प्राथमिकताएँ: यथार्थवादी बनें
| प्राथमिकता | उपयोग | % मेमोरीज़ |
|----------|---------|---------------|
|  | उपयोगकर्ता पहचान, कानूनी जानकारी, अपरिवर्तनीय निर्णय | 5% |
|  | सक्रिय प्रोजेक्ट, महत्वपूर्ण प्राथमिकताएँ | 20% |
|  | अधिकांश तथ्य, नोट्स, संदर्भ | 65% |
|  | क्षणिक, जानना-अच्छा-लगता-है | 10% |
> [!WARNING]
> सब कुछ  चिह्नित न करें। यदि सब कुछ महत्वपूर्ण है, तो कुछ भी महत्वपूर्ण नहीं है।
>  को उन चीज़ों के लिए आरक्षित रखें जिन्हें भूलने पर वास्तविक नुक़सान हो।
कब स्टोर करें और कब नहीं
हमेशा स्टोर करें
- उपयोगकर्ता पहचान (नाम, ईमेल, भूमिका)
- दीर्घकालिक प्राथमिकताएँ
- प्रोजेक्ट निर्णय और तर्क
- पिछली गलतियाँ और सीखे गए सबक
- उपयोगकर्ता को दी गई प्रतिबद्धताएँ
स्टोर न करें
- क्षणिक स्थिति (इसके बजाय वेरिएबल का उपयोग करें)
- शब्दशः वार्तालाप इतिहास (चैट सिस्टम इसे संभालता है)
- संवेदनशील डेटा (पासवर्ड, API कुंजी)
- आसानी से प्राप्त होने वाले तथ्य (वर्तमान तारीख, फ़ाइल सामग्री)
- क्षणिक संदर्भ ( श्रेणी का निम्न प्राथमिकता के साथ उपयोग करें)
मेमोरीज़ अपडेट करना
समान  +  के साथ POST  मौजूदा मेमोरी को अपडेट करता है:
[CODE BLOCK]
> [!TIP]
> स्थिर कुंजी का उपयोग करें ताकि आप डुप्लिकेट बनाए बिना अपडेट कर सकें। LLM
> को जानकारी बदलने पर नई मेमोरी बनाने के बजाय समान कुंजी को पुनः POST करना चाहिए।
मेमोरी जीवनचक्र
[CODE BLOCK]
- Create: पूर्ण संदर्भ के साथ POST /memory
- Active: बार-बार रिकॉल करें, आवश्यकतानुसार अपडेट करें
- Stale: अभी भी प्रासंगिक लेकिन सक्रिय रूप से उपयोग नहीं (कम प्राथमिकता?)
- Archive: प्राथमिकता  पर सेट करें, ऐतिहासिक संदर्भ के लिए रखें
- Delete: अब प्रासंगिक न होने पर DELETE /memory/:id
आवधिक सफ़ाई
[CODE BLOCK]
पैटर्न: मेमोरी इनहेरिटेंस
पदानुक्रमित संदर्भ के लिए (प्रोजेक्ट → उप-प्रोजेक्ट → कार्य):
[CODE BLOCK]
फिर LLM सभी संबंधित मेमोरीज़ खोजने के लिए  सर्च कर सकता है।
पैटर्न: निर्णय लॉग
तर्क के साथ निर्णय स्टोर करें ताकि LLM उन्हें पुनः विवादित न करे:
[CODE BLOCK]
पैटर्न: गलती से बचाव
विशिष्ट बचाव निर्देशों के साथ गलतियाँ स्टोर करें:
[CODE BLOCK]
बचने योग्य एंटी-पैटर्न
> [!WARNING]
> - वार्तालाप लॉग स्टोर करना — चैट सिस्टम इसे संभालता है
> - संपूर्ण फ़ाइलें स्टोर करना — स्क्रिप्ट स्टोर या बाहरी स्टोरेज का उपयोग करें
> - क्षणिक स्थिति स्टोर करना — वेरिएबल का उपयोग करें
> - सीक्रेट्स स्टोर करना — पर्यावरण वेरिएबल का उपयोग करें
> - मेमोरीज़ डुप्लिकेट करना — स्थिर कुंजी का उपयोग करें
> - अति-टैगिंग — प्रति मेमोरी 2-5 टैग आदर्श हैं
> - सब कुछ महत्वपूर्ण है — प्राथमिकताओं में यथार्थवादी रहें
अगले कदम
- Memory API
- Persistent LLM Agent
- Memory Tagging Strategy

────────────────────────────────────────────────────────────
# मल्टी-एजेंट समन्वय
SUMMARY: साझा Synapse minds, tasks और chat का उपयोग करके कई LLM एजेंट्स का समन्वय करें।

मल्टी-एजेंट समन्वय
जब आपके पास संबंधित कार्यों पर काम करने वाले कई LLM एजेंट्स हों, तो Synapse समन्वय परत प्रदान करता है — साझा मेमोरी, कार्य असाइनमेंट और एसिंक्रोनस चैट।
पैटर्न
पैटर्न 1: साझा Mind (एकमात्र सत्य का स्रोत)
सभी एजेंट्स एक Mind Key साझा करते हैं। वे एक ही मेमोरी स्टोर को पढ़ते/लिखते हैं।
[CODE BLOCK]
उपयोग का मामला: एक प्रोजेक्ट पर काम करने वाले एजेंट्स की छोटी टीम।
सेटअप:
[CODE BLOCK]
कार्यों के माध्यम से समन्वय:
[CODE BLOCK]
पैटर्न 2: विशेषीकृत Minds (पृथक संदर्भ)
प्रत्येक एजेंट का अपना mind होता है। वे एक साझा "coordination" mind के माध्यम से संवाद करते हैं।
[CODE BLOCK]
उपयोग का मामला: अलग-अलग विशेषताओं वाले एजेंट्स (कोडिंग, समीक्षा, डिप्लॉयमेंट)।
सेटअप:
[CODE BLOCK]
साझा mind के माध्यम से समन्वय:
[CODE BLOCK]
पैटर्न 3: Hub-and-Spoke (ऑर्केस्ट्रेटर)
एक केंद्रीय ऑर्केस्ट्रेटर एजेंट कार्यों को वर्कर एजेंट्स को असाइन करता है।
[CODE BLOCK]
उपयोग का मामला: समानांतर कार्य वाले जटिल वर्कफ़्लो।
कार्यान्वयन:
[CODE BLOCK]
चैट के माध्यम से समन्वय
एजेंट्स चैट सिस्टम के माध्यम से संवाद कर सकते हैं:
[CODE BLOCK]
> [!NOTE]
> चैट संदेश रोल-टैग किए जाते हैं। एजेंट-टू-एजेंट संदेशों के लिए role=agent सेट करें,
> मानव-टू-एजेंट के लिए role=human।
वेरिएबल के माध्यम से समन्वय
हल्के समन्वय (लॉक, फ़्लैग) के लिए वेरिएबल का उपयोग करें:
[CODE BLOCK]
सर्वोत्तम अभ्यास
> [!TIP]
> - अलग-अलग चिंताओं के लिए अलग-अलग minds का उपयोग करें — coder और reviewer मेमोरी को न मिलाएँ
> - चैट में एजेंट्स को टैग करें — स्पष्ट संबोधन के लिए 
> - कार्य असाइनमेंट के लिए tasks का उपयोग करें — चैट नहीं (चैट चर्चा के लिए है)
> - Idempotency लागू करें — एजेंट्स विफल ऑपरेशन पुनः प्रयास कर सकते हैं
> - सब कुछ लॉग करें — ऑडिटेबिलिटी के लिए निर्णय मेमोरी में स्टोर करें
अगले कदम
- Persistent LLM Agent
- LLM Cookbook
- Webhook Automation

────────────────────────────────────────────────────────────
# परसिस्टेंट LLM एजेंट बनाएँ
SUMMARY: Synapse का उपयोग करके सत्रों में याद रखने वाला LLM एजेंट बनाने की चरण-दर-चरण गाइड।

अवलोकन
यह गाइड Synapse का उपयोग करके एक ऐसे LLM एजेंट को बनाने की प्रक्रिया बताती है जो सत्रों में संदर्भ परसिस्ट करता है। अंत तक, आपका एजेंट:
- सत्र शुरू होने पर पिछला संदर्भ रिकॉल करेगा
- नई जानकारी मिलने पर उसे स्टोर करेगा
- सत्रों में मल्टी-स्टेप कार्यों को ट्रैक करेगा
- एसिंक्रोनस चैट के माध्यम से मनुष्यों से संवाद करेगा
आर्किटेक्चर
[CODE BLOCK]
चरण 1: Mind Key सेटअप करें
[CODE BLOCK]
चरण 2: सत्र शुरुआत प्रोटोकॉल
प्रत्येक सत्र की शुरुआत में, सभी मेमोरीज़ रिकॉल करें:
[CODE BLOCK]
चरण 3: नई जानकारी स्टोर करें
जब भी एजेंट कुछ याद रखने योग्य सीखे:
[CODE BLOCK]
चरण 4: कार्य प्रबंधन
सत्रों में मल्टी-स्टेप कार्य ट्रैक करें:
[CODE BLOCK]
चरण 5: मनुष्यों के साथ एसिंक चैट
टूल कॉल के बीच संदेशों के लिए पोल करें:
[CODE BLOCK]
चरण 6: सत्र समाप्ति प्रोटोकॉल
सत्र समाप्त होने पर, अंतिम संदर्भ स्टोर करें:
[CODE BLOCK]
संपूर्ण पैटर्न
[CODE BLOCK]
सर्वोत्तम अभ्यास
> [!TIP]
>
> - हमेशा पहले रिकॉल करें — संदर्भ लोड किए बिना कार्य शुरू न करें
> - प्रोएक्टिवली स्टोर करें — सत्र समाप्ति तक न प्रतीक्षा करें
> - सार्थक कुंजी का उपयोग करें — , , न कि 
> - सब कुछ टैग करें — टैग खोज और फ़िल्टरिंग में सक्षम बनाते हैं
> - यथार्थवादी प्राथमिकताएँ सेट करें — सब कुछ  नहीं है
अगले कदम
- LLM Cookbook — व्यावहारिक पैटर्न
- Memory Best Practices
- Multi-Agent Coordination

────────────────────────────────────────────────────────────
# सेल्फ-हीलिंग टेस्ट पाइपलाइन
SUMMARY: Synapse मेमोरी का उपयोग करके विफलताओं से सीखने और अपने आप ढलने वाले टेस्ट पाइपलाइन बनाएँ।

सेल्फ-हीलिंग टेस्ट पाइपलाइन
पारंपरिक टेस्ट सूट UI बदलने पर टूट जाते हैं। सेल्फ-हीलिंग टेस्ट पिछली विफलताओं से सीखने और ढलने के लिए Synapse मेमोरी का उपयोग करते हैं — फ्लेकी टेस्ट और रखरखाव बोझ कम करते हैं।
अवधारणा
[CODE BLOCK]
1. टेस्ट चलता है
2. यदि विफल हो, तो विफलता स्टोर करें (क्या गलत हुआ, क्यों, कैसे ठीक करें)
3. अगली बार: निष्पादित करने से पहले संबंधित विफलताएँ रिकॉल करें
4. ज्ञात सुधार स्वचालित रूप से लागू करें
कार्यान्वयन
चरण 1: टेस्ट रैपर
प्रत्येक टेस्ट को मेमोरी रिकॉल/स्टोर के साथ रैप करें:
[CODE BLOCK]
चरण 2: अनुकूलनशील टेस्ट लॉजिक
टेस्ट के अंदर, ज्ञात विफलताओं की जाँच करें और सुधार लागू करें:
[CODE BLOCK]
चरण 3: रिकवरी रणनीतियाँ
रिकवरी रणनीतियों को मेमोरी के रूप में स्टोर करें:
[CODE BLOCK]
चरण 4: CI एकीकरण
[CODE BLOCK]
चरण 5: विफलता विश्लेषण डैशबोर्ड
[CODE BLOCK]
सर्वोत्तम अभ्यास
> [!TIP]
> - ट्रेसबैक स्टोर करें — उनमें ठीक वही पंक्ति होती है जो विफल हुई
> - टेस्ट नाम से टैग करें — तेज़ फ़िल्टरिंग सक्षम बनाता है
> -  श्रेणी का उपयोग करें — नियमित मेमोरीज़ से अलग रखता है
> -  प्राथमिकता सेट करें — विफलताएँ कभी न भूलें
> - आवधिक सफ़ाई — हल किए गए मुद्दों की मेमोरीज़ हटाएँ
> - संवेदनशील डेटा स्टोर न करें — क्रेडेंशियल, PII
स्टोर करने के लिए सामान्य विफलता पैटर्न
| विफलता प्रकार | क्या स्टोर करें |
|--------------|---------------|
| Element not found | चयनकर्ता प्रयास किया गया, पृष्ठ स्थिति, स्क्रीनशॉट |
| Timeout | प्रतीक्षा समय, किसकी प्रतीक्षा की जा रही थी |
| Assertion failed | अपेक्षित बनाम वास्तविक मान |
| Network error | URL, स्टेटस कोड, रिस्पॉन्स बॉडी |
| Permission denied | आवश्यक अनुमति, वर्तमान उपयोगकर्ता भूमिका |
अगले कदम
- Automated iOS Testing
- Memory Best Practices
- Error Recovery Cookbook

────────────────────────────────────────────────────────────
# Webhook स्वचालन
SUMMARY: मेमोरी बदलने पर बाहरी सिस्टम्स को ट्रिगर करें — सिंक, सूचना, स्वचालन।

Webhook स्वचालन
Webhooks आपको Synapse इवेंट्स फायर होने पर बाहरी सिस्टम्स को ट्रिगर करने की सुविधा देते हैं। यह गाइड सामान्य स्वचालन पैटर्न को कवर करती है।
सामान्य पैटर्न
पैटर्न 1: महत्वपूर्ण मेमोरी पर सूचित करें
महत्वपूर्ण मेमोरी स्टोर होने पर Slack संदेश भेजें:
[CODE BLOCK]
Webhook रजिस्टर करें:
[CODE BLOCK]
पैटर्न 2: बाहरी सिस्टम में सिंक करें
मेमोरीज़ को Notion, Obsidian, या किसी बाहरी KB में सिंक करें:
[CODE BLOCK]
पैटर्न 3: CI/CD ट्रिगर करें
"release" मेमोरी स्टोर होने पर डिप्लॉयमेंट ट्रिगर करें:
[CODE BLOCK]
पैटर्न 4: मानव संदेश पर एजेंट को जगाएँ
मानव द्वारा चैट संदेश भेजने पर LLM एजेंट रन ट्रिगर करें:
[CODE BLOCK]
पैटर्न 5: समग्र मेट्रिक्स
मेमोरी वृद्धि, चैट गतिविधि, कार्य पूर्णता ट्रैक करें:
[CODE BLOCK]
सिग्नेचर सत्यापन
स्पूफिंग रोकने के लिए हमेशा webhook सिग्नेचर सत्यापित करें:
[CODE BLOCK]
पुनः प्रयास लॉजिक
Synapse विफल webhooks को एक्सपोनेंशियल बैकऑफ़ के साथ पुनः प्रयास करता है। आपके हैंडलर को यह करना चाहिए:
1. तेज़ी से 200 लौटाएँ — भारी कार्य सिंक्रोनस रूप से न करें
2. कार्य कतारबद्ध करें — बैकग्राउंड जॉब सिस्टम का उपयोग करें
3. Idempotent बनें — समान इवेंट दो बार डिलीवर हो सकता है
[CODE BLOCK]
Webhooks डिबग करना
डिलीवरी इतिहास जाँचें
Webhook डिलीवरी लॉग की जाती है। अपने webhook की हालिया डिलीवरी जाँचें:
[CODE BLOCK]
Webhook मैन्युअली टेस्ट करें
[CODE BLOCK]
सामान्य समस्याएँ
| समस्या | समाधान |
|-------|-----|
| 4xx रिस्पॉन्स | जाँचें कि हैंडलर 200 लौटाता है |
| 5xx रिस्पॉन्स | सर्वर त्रुटि — अपने ऐप लॉग जाँचें |
| Timeout | तेज़ी से 200 लौटाएँ, कार्य एसिंक कतारबद्ध करें |
| डुप्लिकेट डिलीवरी | हैंडलर को idempotent बनाएँ |
| सिग्नेचर मिसमैच | सत्यापित करें कि secret सही है |
सर्वोत्तम अभ्यास
> [!TIP]
> - हमेशा सिग्नेचर सत्यापित करें — इसे कभी न छोड़ें
> - तेज़ी से 200 लौटाएँ — Synapse को ब्लॉक न करें
> - Idempotent बनें — डुप्लिकेट डिलीवरी संभालें
> - विशिष्ट इवेंट्स का उपयोग करें — ,  नहीं
> - डिलीवरी विफलता मॉनिटर करें — अलर्टिंग सेटअप करें
अगले कदम
- Webhooks API
- Cron & Scheduler
- Persistent LLM Agent

## श्रेणी: अवधारणाएँ
Synapse के पीछे की आर्किटेक्चर और अवधारणाएँ।

────────────────────────────────────────────────────────────
# Synapse आर्किटेक्चर
SUMMARY: Synapse कैसे बना है — Fastify, PostgreSQL, FTS5, embeddings, MCP server।

Synapse आर्किटेक्चर
Synapse एक मल्टी-टैनेंट मेमोरी API है जो Fastify, FTS5 के साथ PostgreSQL, और सिमेंटिक खोज के लिए एक वैकल्पिक embeddings सेवा पर बना है।
उच्च-स्तरीय आर्किटेक्चर
[CODE BLOCK]
मुख्य घटक
1. Synapse API (Fastify)
मुख्य HTTP server। संभालता है:
- REST एंडपॉइंट्स (, , , आदि)
- प्रमाणीकरण (एजेंट्स के लिए Mind Key, मानवों के लिए JWT)
- रेट लिमिटिंग (केवल  प्रमाणीकरण)
- स्टेटिक फ़ाइल सर्विंग (, , आदि पर वेब UI)
- Webhook डिस्पैच
प्रदर्शन के लिए Fastify 5 के साथ बना। उत्पादन में पोर्ट 12800 पर चलता है।
2. FTS5 के साथ PostgreSQL
प्राथमिक डेटा स्टोर। फुल-टेक्स्ट खोज के लिए FTS5 एक्सटेंशन के साथ PostgreSQL का उपयोग करता है।
मुख्य तालिकाएँ:
| तालिका | उद्देश्य |
|-------|---------|
|  | उपयोगकर्ता खाते |
|  | Mind दायरे (प्रत्येक के पास Mind Key है) |
|  | FTS5 वर्चुअल तालिका के साथ मेमोरी रिकॉर्ड्स |
|  | कार्य प्रबंधन |
|  | चैट इतिहास |
|  | स्थायी स्क्रिप्ट्स |
|  | Webhook पंजीकरण |
|  | शेड्यूल किए गए कार्य |
|  | Key-value स्टोर |
|  | ऑडिट ट्रेल |
FTS5 सभी मेमोरी सामग्री में सब-मिलीसेकंड फुल-टेक्स्ट खोज सक्षम बनाता है। विवरण के लिए FTS5 Search देखें।
3. Embeddings सेवा (वैकल्पिक)
सिमेंटिक खोज के लिए, Synapse मेमोरी सामग्री के वेक्टर embeddings जनरेट करता है। ये मेमोरीज़ के साथ संग्रहीत होते हैं और समानता खोज के लिए उपयोग किए जाते हैं।
- प्रदाता: कॉन्फ़िगर करने योग्य (OpenAI, लोकल मॉडल, आदि)
-  तालिका में  कॉलम के रूप में संग्रहीत
-  एंडपॉइंट द्वारा उपयोग
- सिमेंटिक खोज देखें
4. MCP Server (अलग सेवा)
Synapse MCP server एक अलग प्रक्रिया के रूप में चलता है (पोर्ट 13100)। यह:
- Model Context Protocol के माध्यम से 79 टूल्स एक्सपोज़ करता है
- stdio, HTTP/SSE, और WebSocket ट्रांसपोर्ट का समर्थन करता है
- MCP टूल कॉल्स को Synapse API कॉल्स में अनुवादित करता है
- मल्टी-टैनेंट: प्रति सत्र एक Mind Key
5. Browser Proxy (अलग सेवा)
ब्राउज़र ऑटोमेशन के लिए, एक अलग Playwright-आधारित सेवा पोर्ट 13000 पर चलती है। MCP server  टूल्स के लिए इसे कॉल कर सकता है।
6. SSH Proxy (अलग सेवा)
SSH-आधारित रिमोट कमांड्स के लिए, एक अलग सेवा पोर्ट 12900 पर चलती है।
मल्टी-टैनेंसी मॉडल
[CODE BLOCK]
प्रत्येक mind पूरी तरह से अलग है। Mind Keys ठीक एक mind तक पहुँच प्रदान करते हैं।
JWTs उपयोगकर्ता खाते तक पहुँच प्रदान करते हैं (minds प्रबंधित करने के लिए)।
विवरण के लिए मल्टी-टैनेंसी देखें।
अनुरोध प्रवाह
मेमोरी स्टोर अनुरोध
[CODE BLOCK]
मेमोरी खोज अनुरोध
[CODE BLOCK]
परिनियोजन
Synapse एक Docker कंटेनर के रूप में परिनियोजित होता है।  देखें:
[CODE BLOCK]
प्रदर्शन विशेषताएँ
| ऑपरेशन | विलंबता | थ्रूपुट |
|-----------|---------|------------|
| मेमोरी स्टोर | 5ms | 1000+ req/s |
| मेमोरी रिकॉल | 20ms | 500 req/s |
| FTS5 खोज | 10ms | 800 req/s |
| सिमेंटिक खोज | 50ms | 200 req/s |
| चैट poll | 5ms | 2000 req/s |
अगले कदम
- मेमोरी मॉडल
- मल्टी-टैनेंसी
- FTS5 Search

────────────────────────────────────────────────────────────
# FTS5 फुल-टेक्स्ट खोज
SUMMARY: Synapse SQLite FTS5 का उपयोग सब-मिलीसेकंड फुल-टेक्स्ट मेमोरी खोज के लिए कैसे करता है।

FTS5 फुल-टेक्स्ट खोज
Synapse तेज़, लचीली मेमोरी खोज के लिए FTS5 (Full-Text Search 5) का उपयोग करता है। यह पृष्ठ बताता है कि यह कैसे काम करता है और इसे प्रभावी ढंग से कैसे उपयोग करें।
FTS5 क्या है?
FTS5 एक SQLite एक्सटेंशन है (एक्सटेंशन के माध्यम से PostgreSQL में भी उपलब्ध) जो फुल-टेक्स्ट खोज क्षमताएँ प्रदान करता है। यह:
- तेज़ कीवर्ड खोज के लिए टेक्स्ट सामग्री अनुक्रमित करता है
- बूलियन ऑपरेटर्स (AND, OR, NOT) का समर्थन करता है
- उद्धरण चिह्नों के साथ वाक्यांश मिलान का समर्थन करता है
-  के साथ उपसर्ग मिलान का समर्थन करता है
- प्रासंगिकता द्वारा परिणामों को क्रमबद्ध करता है
Synapse सभी मेमोरी सामग्री को अनुक्रमित करने के लिए FTS5 का उपयोग करता है, हज़ारों मेमोरीज़ में सब-मिलीसेकंड खोज सक्षम बनाता है।
Synapse FTS5 का उपयोग कैसे करता है
जब आप :
1. मेमोरी सामग्री  तालिका में संग्रहीत होती है
2. सामग्री FTS5 वर्चुअल तालिका में भी डाली जाती है
3. FTS5 स्वचालित रूप से सामग्री को टोकनाइज़ और अनुक्रमित करता है
जब आप :
1. Synapse FTS5 सिंटैक्स का उपयोग करके क्वेरी पार्स करता है
2. FTS5 इंडेक्स के विरुद्ध  निष्पादित करता है
3.  द्वारा फ़िल्टर करता है (टैनेंट आइसोलेशन)
4. क्रमबद्ध परिणाम लौटाता है
क्वेरी सिंटैक्स
सरल कीवर्ड खोज
[CODE BLOCK]
"docker" युक्त मेमोरीज़ लौटाता है।
कई कीवर्ड्स (अंतर्निहित AND)
[CODE BLOCK]
BOTH "docker" और "swarm" युक्त मेमोरीज़ लौटाता है।
वाक्यांश मिलान
[CODE BLOCK]
सटीक वाक्यांश "docker swarm" युक्त मेमोरीज़ लौटाता है।
उपसर्ग मिलान
[CODE BLOCK]
"docker" से शुरू होने वाले शब्दों वाली मेमोरीज़ लौटाता है (जैसे "dockers", "dockerfile", "dockerize")।
बूलियन OR
[CODE BLOCK]
"docker" OR "kubernetes" युक्त मेमोरीज़ लौटाता है।
बूलियन NOT
[CODE BLOCK]
"docker" लेकिन NOT "swarm" युक्त मेमोरीज़ लौटाता है।
समूहीकरण
[CODE BLOCK]
"docker" या "kubernetes", लेकिन "test" नहीं युक्त मेमोरीज़ लौटाता है।
व्यावहारिक उदाहरण
किसी परियोजना के बारे में मेमोरीज़ खोजें
[CODE BLOCK]
सटीक वाक्यांश खोजें
[CODE BLOCK]
परीक्षण मेमोरीज़ बहिष्कृत करें
[CODE BLOCK]
तकनीक द्वारा खोजें
[CODE BLOCK]
क्रमांकन
FTS5 BM25 एल्गोरिथ्म का उपयोग करके प्रासंगिकता द्वारा परिणाम क्रमबद्ध करता है। कारक:
- शब्द आवृत्ति (शब्द कितनी बार दिखाई देता है)
- विपरीत दस्तावेज़ आवृत्ति (दुर्लभ शब्द उच्च क्रम के)
- दस्तावेज़ लंबाई (शब्द वाले छोटे दस्तावेज़ उच्च क्रम के)
- कॉलम भार (title > content)
परिणाम क्रम क्रम में लौटाए जाते हैं (सबसे प्रासंगिक पहले)।
प्रदर्शन
| ऑपरेशन | विलंबता |
|-----------|---------|
| 100 मेमोरीज़ खोज | < 5ms |
| 1,000 मेमोरीज़ खोज | < 10ms |
| 10,000 मेमोरीज़ खोज | < 25ms |
| 100,000 मेमोरीज़ खोज | < 100ms |
FTS5 रीड-हेवी वर्कलोड के लिए अत्यधिक अनुकूलित है।
सीमाएँ
स्टेमिंग
FTS5 डिफ़ॉल्ट रूप से स्टेमिंग नहीं करता। "running" और "run" भिन्न शब्द हैं।
समाधान: उपसर्ग मिलान का उपयोग करें: 
टाइपो सहिष्णुता
FTS5 फ़ज़ी मिलान का समर्थन नहीं करता। टाइपो कोई परिणाम नहीं लौटाएगा।
समाधान: वैचारिक मिलान के लिए सिमेंटिक खोज () का उपयोग करें।
स्टॉप शब्द
सामान्य शब्द (the, a, an, is) अनुक्रमित होते हैं लेकिन खोज के लिए उपयोगी नहीं हो सकते। FTS5 इसे स्वचालित रूप से संभालता है।
FTS5 बनाम सिमेंटिक खोज
| पहलू | FTS5 | सिमेंटिक खोज |
|--------|------|-----------------|
| गति | सब-मिलीसेकंड | 50-100ms |
| मिलान | सटीक कीवर्ड्स | वैचारिक |
| टाइपो सहिष्णुता | कोई नहीं | कुछ |
| स्टेमिंग | कोई नहीं | अंतर्निहित |
| Embeddings आवश्यक | नहीं | हाँ |
| के लिए सर्वोत्तम | विशिष्ट शब्द | अवधारणाएँ |
जब आप कीवर्ड्स जानते हैं तब FTS5 का उपयोग करें। जब आप "X के बारे में मेमोरीज़" चाहते हैं जहाँ X अलग ढंग से वर्णित है तब सिमेंटिक खोज का उपयोग करें।
सर्वोत्तम प्रथाएँ
> [!TIP]
> - विशिष्ट शब्दों का उपयोग करें — "docker swarm" "container orchestration" से बेहतर है
> - वाक्यांशों को उद्धृत करें —  वाक्यांश मिलान सुनिश्चित करता है
> - विविधताओं के लिए उपसर्ग का उपयोग करें —  "deploy", "deployment", "deploying" पकड़ता है
> - शोर बहिष्कृत करें —  परीक्षण मेमोरीज़ फ़िल्टर करता है
> - टैग्स के साथ संयोजित करें —  परिणाम संकरा करता है
अगले कदम
- सिमेंटिक खोज
- Memory API
- मेमोरी सर्वोत्तम प्रथाएँ

────────────────────────────────────────────────────────────
# मेमोरी मॉडल
SUMMARY: मेमोरीज़ कैसे संरचित हैं — श्रेणियाँ, कुंजी, टैग्स, प्राथमिकताएँ, स्रोत, सत्यापन।

मेमोरी मॉडल
Synapse का मेमोरी मॉडल LLM एजेंट्स के लिए डिज़ाइन किया गया है — विश्वसनीय रिकॉल के लिए पर्याप्त संरचित, किसी भी डोमेन के लिए पर्याप्त लचीला।
मेमोरी शरीर रचना
[CODE BLOCK]
फ़ील्ड्स
| फ़ील्ड | प्रकार | आवश्यक | विवरण |
|-------|------|----------|-------------|
|  | string | auto | अद्वितीय ID (memxxx) |
|  | enum | ✅ | 8 श्रेणियों में से एक |
|  | string | ✅ | स्थिर पहचानकर्ता (अपडेट के लिए उपयोग) |
|  | string | ✅ | मेमोरी सामग्री (कोई भी टेक्स्ट) |
|  | string[] | – | खोज और फ़िल्टरिंग के लिए |
|  | enum | – | low, normal, high, critical (डिफ़ॉल्ट: normal) |
|  | enum | auto | user, agent (किसने स्टोर किया) |
|  | bool | auto | क्या किसी मानव ने इसे सत्यापित किया? |
|  | float | – | 0.0 से 1.0 (डिफ़ॉल्ट: user के लिए 1.0, agent के लिए 0.7) |
|  | timestamp | – | यह मेमोरी कब भूलनी है |
|  | string | auto | कौन सा mind इसका मालिक है |
|  | timestamp | auto | पहले स्टोर किया गया |
|  | timestamp | auto | अंतिम बार संशोधित |
श्रेणियाँ
आठ श्रेणियाँ सामान्य LLM एजेंट उपयोग के मामलों को कवर करती हैं:
| श्रेणी | उद्देश्य | उदाहरण सामग्री |
|----------|---------|-----------------|
|  | उपयोगकर्ता कौन है | "User is Michael Schäfer, software engineer in Berlin" |
|  | उपयोगकर्ता प्राथमिकताएँ | "Prefers concise technical responses" |
|  | सत्यापित योग्य तथ्य | "Office is in Berlin, timezone Europe/Berlin" |
|  | परियोजना स्थिति | "Synapse v1.5.0 deployed, working on v1.6.0 docs" |
|  | उपयोगकर्ता के कौशल | "Advanced Python, 10+ years" |
|  | पिछली त्रुटियाँ | "Forgot to bump npm version — CI failed" |
|  | सत्र संदर्भ | "Currently reviewing PR #42" |
|  | विविध नोट्स | "Try Redis for caching next sprint" |
कुंजी: स्थिर पहचानकर्ता
 फ़ील्ड महत्वपूर्ण है — यह डुप्लिकेट बनाए बिना मेमोरीज़ अपडेट करने का तरीका है।
[CODE BLOCK]
कुंजी नियम:
- (category, mind) के भीतर अद्वितीय होनी चाहिए
-  का उपयोग करें
- स्पष्टता के लिए श्रेणी के साथ उपसर्ग: , 
- स्थिर रखें — निर्माण के बाद कुंजी न बदलें
टैग्स: खोज के लिए
टैग्स तेज़ फ़िल्टरिंग और खोज सक्षम बनाते हैं:
[CODE BLOCK]
टैग सर्वोत्तम प्रथाएँ:
- प्रति मेमोरी 2-5 टैग्स (अधिक टैग न करें)
- निरंतरता के लिए लोअरकेस
- परियोजना नाम, विषय, तकनीकों का उपयोग करें
- टैग्स केस-असंवेदनशील हैं
प्राथमिकता स्तर
| प्राथमिकता | कब उपयोग करें | रिकॉल व्यवहार |
|----------|-------------|-----------------|
|  | पहचान, कानूनी, अपरिवर्तनीय | हमेशा रिकॉल के शीर्ष पर |
|  | सक्रिय परियोजनाएँ, मुख्य प्राथमिकताएँ | रिकॉल में प्रमुख |
|  | अधिकांश मेमोरीज़ (डिफ़ॉल्ट) | मानक रिकॉल क्रम |
|  | क्षणिक, जानना-अच्छा | सारांशित हो सकता है |
 प्राथमिकता द्वारा (critical पहले), फिर नवीनता द्वारा क्रमबद्ध करता है।
स्रोत: User बनाम Agent
मेमोरीज़ को  के साथ टैग किया जाता है:
-  — किसी मानव द्वारा स्टोर किया गया (JWT या human UI के माध्यम से)
-  — किसी LLM एजेंट द्वारा स्टोर किया गया (Mind Key के माध्यम से)
यह प्रभावित करता है:
- सत्यापन:  मेमोरीज़ ऑटो-सत्यापित हैं,  मेमोरीज़ नहीं
- विश्वास्यता:  का डिफ़ॉल्ट 1.0,  का 0.7
- रिकॉल:  असत्यापित मेमोरीज़ को "(unverified)" से चिह्नित करता है
> [!NOTE]
> -स्रोत मेमोरीज़ के प्रति उचित संदेह रखें। ये सीधे उपयोगकर्ता द्वारा बताई गई नहीं, बल्कि अनुमानित या मानी गई हो सकती हैं।
सत्यापन
 फ़्लैग दर्शाता है कि किसी मानव ने मेमोरी की पुष्टि की है:
-  मेमोरीज़: ऑटो-सत्यापित ()
-  मेमोरीज़: डिफ़ॉल्ट असत्यापित ()
मेमोरीज़ इसके माध्यम से सत्यापित करें:
[CODE BLOCK]
> [!NOTE]
> सत्यापन के लिए Mind Key (एजेंट प्रमाणीकरण) नहीं, JWT (मानव प्रमाणीकरण) आवश्यक है। यह सुनिश्चित करता है कि केवल मानव ही मेमोरीज़ को सत्यापित के रूप में चिह्नित कर सकें।
विश्वास्यता
 फ़ील्ड (0.0 से 1.0) दर्शाता है कि मेमोरी कितनी विश्वसनीय है:
- 1.0 — उपयोगकर्ता द्वारा सीधे बताई गई
- 0.7 — एजेंट द्वारा अनुमानित
- 0.5 — अनिश्चित, सत्यापन चाहिए
- 0.0 — स्पष्ट रूप से संदिग्ध
स्टोर करते समय विश्वास्यता सेट करें:
[CODE BLOCK]
समाप्ति
समय-संवेदनशील मेमोरीज़ के लिए  सेट करें:
[CODE BLOCK]
समाप्त मेमोरीज़  द्वारा लौटाई नहीं जातीं (लेकिन DB में अभी भी मौजूद हैं)।
जल्द ही समाप्त होने वाली मेमोरीज़ देखने के लिए  का उपयोग करें।
मेमोरी जीवनचक्र
[CODE BLOCK]
रिकॉल व्यवहार
 LLM संदर्भ के लिए अनुकूलित सादे-टेक्स्ट सारांश लौटाता है:
[CODE BLOCK]
- प्राथमिकता द्वारा क्रमबद्ध (critical → low), फिर नवीनता द्वारा
- असत्यापित मेमोरीज़  से चिह्नित
- संदर्भ के लिए टैग्स शामिल
- सादा टेक्स्ट (कोई JSON पार्सिंग आवश्यक नहीं)
अगले कदम
- Memory API
- मेमोरी सर्वोत्तम प्रथाएँ
- FTS5 Search

────────────────────────────────────────────────────────────
# मल्टी-टैनेंसी और आइसोलेशन
SUMMARY: Synapse उपयोगकर्ताओं और minds के बीच डेटा को कैसे अलग करता है — सुरक्षा सीमाओं की व्याख्या।

मल्टी-टैनेंसी और आइसोलेशन
Synapse मल्टी-टैनेंट है: कई उपयोगकर्ता, प्रत्येक के पास कई minds, जो एक-दूसरे से पूरी तरह अलग हैं। यह पृष्ठ आइसोलेशन मॉडल की व्याख्या करता है।
टैनेंट पदानुक्रम
[CODE BLOCK]
आइसोलेशन स्तर
स्तर 1: उपयोगकर्ता आइसोलेशन
प्रत्येक उपयोगकर्ता खाता अलग है। Alice नहीं कर सकती:
- Bob के minds देख सकती है
- Bob की मेमोरीज़ एक्सेस कर सकती है (अपने JWT के साथ भी)
- Bob की खाता जानकारी सूचीबद्ध कर सकती है
लागू द्वारा: सभी तालिकाओं पर  कॉलम, JWT में  शामिल, सभी क्वेरीज़  द्वारा फ़िल्टर करती हैं।
स्तर 2: Mind आइसोलेशन
किसी उपयोगकर्ता के भीतर, प्रत्येक mind अलग है। Mind A नहीं कर सकता:
- Mind B की मेमोरीज़ देख सकता है
- Mind B के कार्य, चैट, स्क्रिप्ट्स एक्सेस कर सकता है
लागू द्वारा: सभी डेटा तालिकाओं पर  कॉलम, Mind Key में  शामिल, सभी क्वेरीज़  द्वारा फ़िल्टर करती हैं।
> [!CRITICAL]
> Mind Key आइसोलेशन प्राथमिक सुरक्षा सीमा है। लीक हुई Mind Key उस mind के डेटा तक पूर्ण पहुँच प्रदान करती है — लेकिन केवल उसी mind तक।
प्रमाणीकरण टोकन
| टोकन | दायरा | क्या एक्सेस कर सकता है |
|-------|-------|-------------------|
| Mind Key | एकल mind | केवल उस mind का डेटा |
| JWT | उपयोगकर्ता खाता | खाता प्रबंधन (minds बनाएँ/सूचीबद्ध करें/हटाएँ) |
| Computer Token | एकल कंप्यूटर | उस कंप्यूटर के कमांड्स |
क्रॉस-Mind एक्सेस
उसी उपयोगकर्ता के भीतर
उपयोगकर्ता JWT के माध्यम से अपने सभी minds एक्सेस कर सकता है (जैसे  सभी को सूचीबद्ध करता है)।
लेकिन मेमोरी डेटा पढ़ने/लिखने के लिए, उन्हें विशिष्ट Mind Key की आवश्यकता है।
उपयोगकर्ताओं के बीच
उपयोगकर्ता एक-दूसरे के डेटा को एक्सेस नहीं कर सकते — जब तक वे Sharing API के माध्यम से स्पष्ट रूप से कोई mind साझा न करें:
[CODE BLOCK]
साझाकरण के बाद, Bob अपने JWT के माध्यम से Mind A एक्सेस कर सकता है (केवल पढ़ने के लिए यदि )।
सुरक्षा सीमाएँ
[CODE BLOCK]
सामान्य मल्टी-टैनेंसी पैटर्न
पैटर्न 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 एक्सेस नहीं कर सकता
[CODE BLOCK]
परीक्षण: JWT सीधे मेमोरी डेटा नहीं पढ़ सकता
[CODE BLOCK]
सर्वोत्तम प्रथाएँ
> [!TIP]
> - प्रति परियोजना/संदर्भ एक mind का उपयोग करें — आइसोलेशन आपका मित्र है
> - Mind Keys कभी साझा न करें — इसके बजाय Sharing API का उपयोग करें
> - समझौता होने पर Mind Keys रोटेट करें (mind हटाएँ, नया बनाएँ)
> - साझा minds का ऑडिट करें — समय-समय पर  समीक्षा करें
> - मानव UI के लिए JWT का उपयोग करें — अंतिम उपयोगकर्ताओं को Mind Keys कभी एक्सपोज़ न करें
अगले कदम
- प्रमाणीकरण
- Mind Key vs JWT
- आर्किटेक्चर

────────────────────────────────────────────────────────────
# सिमेंटिक खोज (Embeddings)
SUMMARY: वेक्टर embeddings का उपयोग करके वैचारिक मेमोरी खोज — कीवर्ड्स नहीं, अर्थ द्वारा खोजें।

सिमेंटिक खोज (Embeddings)
Synapse वेक्टर embeddings का उपयोग करके सिमेंटिक खोज का समर्थन करता है। FTS5 (कीवर्ड मिलान) के विपरीत, सिमेंटिक खोज अर्थ द्वारा मेमोरीज़ खोजती है — भले ही कोई कीवर्ड मेल न खाए।
यह कैसे काम करता है
[CODE BLOCK]
Embeddings क्या हैं?
Embeddings टेक्स्ट के संख्यात्मक वेक्टर प्रतिनिधित्व हैं। समान अर्थ वाले टेक्स्ट के समान वेक्टर होते हैं। Synapse प्रत्येक मेमोरी की सामग्री के लिए एक वेक्टर (जैसे 1536 आयाम) जनरेट करता है।
कोसाइन समानता
सिमेंटिक रूप से समान मेमोरीज़ खोजने के लिए, Synapse क्वेरी वेक्टर और प्रत्येक मेमोरी वेक्टर के बीच कोसाइन समानता की गणना करता है। उच्च समानता = अधिक प्रासंगिक।
सिमेंटिक खोज कब उपयोग करें
सिमेंटिक खोज का उपयोग करें जब:
- आप "X के बारे में मेमोरीज़" चाहते हैं जहाँ X स्टोर किए गए से अलग ढंग से वर्णित है
- FTS5 कोई परिणाम नहीं लौटाता (कोई कीवर्ड मिलान नहीं)
- आप वैचारिक समूहीकरण चाहते हैं (जैसे सभी "deployment" मेमोरीज़, भले ही कुछ "release" कहें)
- क्वेरी एक प्रश्न है: "how do we handle authentication?"
FTS5 का उपयोग करें जब:
- आप सटीक कीवर्ड्स जानते हैं
- आपको बूलियन लॉजिक (AND, OR, NOT) चाहिए
- आपको सब-मिलीसेकंड प्रतिक्रिया चाहिए
- आप वाक्यांश मिलान चाहते हैं
एंडपॉइंट
GET /memory/semantic-search
[CODE BLOCK]
प्रतिक्रिया:
[CODE BLOCK]
उदाहरण
परिनियोजन मेमोरीज़ खोजें
[CODE BLOCK]
"deployment", "release", "publishing", "rolling out", आदि के बारे में मेमोरीज़ लौटाता है।
प्रमाणीकरण पैटर्न खोजें
[CODE BLOCK]
login, auth, JWT, session management, OAuth, आदि के बारे में मेमोरीज़ लौटाता है।
समान मेमोरीज़ खोजें
[CODE BLOCK]
सिमेंटिक समानता का उपयोग करता है (साझा टैग्स और embedding वेक्टर्स के माध्यम से)।
Embedding जनरेशन
Embeddings कब जनरेट होते हैं?
- मेमोरी स्टोर पर — यदि embeddings सेवा कॉन्फ़िगर की गई है, तो embedding तुल्यकालिक रूप से जनरेट होता है
- बैच जनरेशन —  उन मेमोरीज़ के लिए embeddings जनरेट करता है जिनके पास नहीं हैं
- अतुल्यकालिक अपडेट — जब सामग्री अपडेट होती है, embedding पुनः जनरेट होता है
Embedding प्रदाता
Synapse कॉन्फ़िगर करने योग्य embedding प्रदाताओं का समर्थन करता है:
- OpenAI (, )
- लोकल मॉडल (Ollama या समान के माध्यम से)
- कस्टम (embeddings इंटरफ़ेस लागू करें)
पर्यावरण वेरिएबल्स के माध्यम से कॉन्फ़िगर करें:
[CODE BLOCK]
बैच जनरेशन
कई मेमोरीज़ वाले minds के लिए जिनमें embeddings गायब हैं:
[CODE BLOCK]
प्रदर्शन
| ऑपरेशन | विलंबता |
|-----------|---------|
| Embedding जनरेट करें (OpenAI) | 100-200ms |
| सिमेंटिक खोज (1k मेमोरीज़) | 50-100ms |
| सिमेंटिक खोज (10k मेमोरीज़) | 200-500ms |
| बैच जनरेशन (100 मेमोरीज़) | 10-20s |
> [!NOTE]
> वेक्टर गणना के कारण सिमेंटिक खोज FTS5 से धीमी है। ज्ञात कीवर्ड्स के लिए FTS5, वैचारिक क्वेरीज़ के लिए सिमेंटिक का उपयोग करें।
सीमाएँ
Embeddings लागत
यदि OpenAI का उपयोग कर रहे हैं, तो embeddings जनरेट करने का खर्च आता है (text-embedding-3-small के लिए $0.02 प्रति 1M टोकन)। 10,000 मेमोरीज़ औसतन 100 टोकन प्रत्येक के लिए, यह $0.02 है — नगण्य।
कोल्ड स्टार्ट
Embeddings कॉन्फ़िगर किए जाने से पहले स्टोर की गई मेमोरीज़ में embeddings नहीं होंगे। बैकफ़िल के लिए  चलाएँ।
प्रदाता निर्भरता
यदि embeddings प्रदाता डाउन है, तो सिमेंटिक खोज विनम्रतापूर्वक विफल होती है (खाली परिणाम या त्रुटि लौटाती है)। FTS5 अभी भी काम करता है।
जब Embeddings उपलब्ध नहीं हैं
यदि embeddings सेवा कॉन्फ़िगर नहीं है:
-  503 Service Unavailable लौटाता है
-  अभी भी काम करता है (बस कोई embedding जनरेट नहीं होता)
- FTS5 खोज अभी भी काम करती है
सर्वोत्तम प्रथाएँ
> [!TIP]
> - वैचारिक क्वेरीज़ के लिए सिमेंटिक का उपयोग करें — "how do we handle X?"
> - विशिष्ट शब्दों के लिए FTS5 का उपयोग करें — "docker swarm"
> - नियमित रूप से embeddings बैकफ़िल करें — 
> - प्रदाता स्वास्थ्य की निगरानी करें — सिमेंटिक खोज इस पर निर्भर करती है
> - टैग्स के साथ संयोजित करें — सिमेंटिक + टैग फ़िल्टर परिणाम संकरा करता है
अगले कदम
- FTS5 Search
- Memory API
- आर्किटेक्चर

## श्रेणी: LLM कुकबुक
LLM एजेंटों के लिए व्यंजन और पैटर्न।

────────────────────────────────────────────────────────────
# चैट पोलिंग पैटर्न
SUMMARY: बिना अपने वर्कफ़्लो को ब्लॉक किए टूल कॉल के बीच मानव संदेशों के लिए कैसे पोल करें।

चैट पोलिंग पैटर्न
चैट सिस्टम अतुल्यकालिक है — मनुष्य आपके काम करते समय संदेश छोड़ सकते हैं। यह पैटर्न दिखाता है कि बिना अपने वर्कफ़्लो को ब्लॉक किए संदेशों के लिए कैसे पोल करें।
पैटर्न
[CODE BLOCK]
टूल कॉल के बीच पोल करें, कसे हुए लूप में नहीं।
टूल कॉल के बीच क्यों पोल करें?
- ब्लॉक न करें — कसे हुए लूप में पोलिंग API कॉल बर्बाद करती है
- संदेश मिस न करें — बहुत कम पोलिंग का मतलब है धीमी प्रतिक्रिया
- सही संतुलन — हर 30-60 सेकंड में पोल करें, या प्रत्येक टूल कॉल के बाद
कार्यान्वयन
बुनियादी पोलिंग
[CODE BLOCK]
पैटर्न 1: प्रत्येक टूल कॉल के बाद पोल करें
[CODE BLOCK]
पैटर्न 2: समय-आधारित पोलिंग
[CODE BLOCK]
पैटर्न 3: इवेंट-संचालित (webhooks के साथ)
रियल-टाइम सूचना के लिए, एक webhook रजिस्टर करें:
[CODE BLOCK]
फिर आपका webhook हैंडलर एजेंट को जगा सकता है:
[CODE BLOCK]
संदेश हैंडलिंग पैटर्न
पैटर्न: स्वीकार करें फिर प्रोसेस करें
[CODE BLOCK]
पैटर्न: बैच प्रोसेसिंग के लिए कतारबद्ध करें
[CODE BLOCK]
पैटर्न: प्राथमिकता रूटिंग
[CODE BLOCK]
पोलिंग आवृत्ति
| उपयोग का मामला | आवृत्ति |
|----------|-----------|
| इंटरैक्टिव एजेंट (मानव प्रतीक्षा कर रहा) | हर 5-10 सेकंड |
| बैकग्राउंड एजेंट | हर 30-60 सेकंड |
| बैच प्रोसेसिंग | हर 5 मिनट |
| Webhook-ट्रिगर | पोल न करें — webhooks का उपयोग करें |
> [!WARNING]
> 5 सेकंड में एक बार से अधिक पोलिंग API कॉल बर्बाद करती है। 
> एंडपॉइंट संदेश लंबित होने पर तुरंत लौटता है, इसलिए तेज़ पोलिंग से कोई लाभ नहीं है।
मल्टी-एजेंट चैट
एजेंट-टू-एजेंट संवाद के लिए:
[CODE BLOCK]
सर्वोत्तम अभ्यास
> [!TIP]
> - टूल कॉल के बीच पोल करें — कसे हुए लूप में नहीं
> - तुरंत स्वीकार करें — मानव को पता चले कि आपको संदेश मिला
> - अतुल्यकालिक रूप से प्रोसेस करें — लंबे काम पर ब्लॉक न करें
> - रियल-टाइम के लिए webhooks का उपयोग करें — पोलिंग में लेटेंसी होती है
> - 5 सेकंड में एक बार से अधिक पोल न करें — API कॉल बर्बाद होते हैं
सामान्य समस्याएँ
संदेश गायब हो जाना
-  स्वचालित रूप से संदेशों को पढ़ा हुआ चिह्नित करता है
- यदि आप उन्हें प्रोसेस नहीं करते, तो वे चले जाते हैं
- समाधान: हमेशा लौटने से पहले संदेशों को प्रोसेस करें
डुप्लिकेट रिप्लाई
- यदि आपका हैंडलर क्रैश हो जाता है, तो आप दो बार रिप्लाई कर सकते हैं
- समाधान: हैंडलर को idempotent बनाएँ (जाँचें कि पहले से रिप्लाई हो चुका है या नहीं)
धीमी प्रतिक्रिया
- 60s में पोलिंग का मतलब 60s तक की लेटेंसी
- समाधान: हर 10-30s में पोल करें, या webhooks का उपयोग करें
अगले कदम
- Chat API
- Session Start Pattern
- Error Recovery

────────────────────────────────────────────────────────────
# एजेंट्स के लिए त्रुटि रिकवरी
SUMMARY: LLM एजेंट्स को त्रुटियों को कैसे संभालना चाहिए और रिकवर करना चाहिए — पुनः प्रयास, स्टोर, सीखें।

एजेंट्स के लिए त्रुटि रिकवरी
त्रुटियाँ होती रहती हैं। नेटवर्क विफल होते हैं, APIs 500 लौटाते हैं, Mind Keys समाप्त हो जाते हैं। यह गाइड दिखाती है कि LLM एजेंट्स को त्रुटियों को सुंदर ढंग से कैसे संभालना चाहिए और उनसे कैसे सीखना चाहिए।
त्रुटि हैंडलिंग सिद्धांत
1. बैकऑफ़ के साथ पुनः प्रयास — क्षणिक त्रुटियाँ अक्सर हल हो जाती हैं
2. त्रुटि स्टोर करें — पैटर्न से सीखें
3. सुंदरता से डिग्रेड करें — पूरा सत्र क्रैश न करें
4. मानव को सूचित करें — उन त्रुटियों के लिए जिन्हें आप हल नहीं कर सकते
HTTP त्रुटि हैंडलिंग
एक्सपोनेंशियल बैकऑफ़ के साथ पुनः प्रयास
[CODE BLOCK]
Auth त्रुटि हैंडलिंग
[CODE BLOCK]
त्रुटियों को मेमोरी के रूप में स्टोर करना
जब त्रुटियाँ होती हैं, तो उन्हें स्टोर करें ताकि भविष्य के सत्र सीख सकें:
[CODE BLOCK]
सामान्य त्रुटि परिदृश्य
परिदृश्य 1: Mind Key अमान्य
[CODE BLOCK]
परिदृश्य 2: नेटवर्क त्रुटि
[CODE BLOCK]
परिदृश्य 3: रेट लिमिट
[CODE BLOCK]
परिदृश्य 4: सर्वर त्रुटि (5xx)
[CODE BLOCK]
परिदृश्य 5: टूल कॉल विफल
[CODE BLOCK]
पैटर्न: सर्किट ब्रेकर
बार-बार विफलताओं के लिए, कुछ समय के लिए प्रयास बंद करें:
[CODE BLOCK]
सर्वोत्तम अभ्यास
> [!TIP]
> - हमेशा क्षणिक त्रुटियों का पुनः प्रयास करें — नेटवर्क विफल होते हैं, सर्वर डगमगाते हैं
> - क्लाइंट त्रुटियों (4xx) का पुनः प्रयास न करें — वे स्वयं ठीक नहीं होंगी
> - त्रुटियों को मेमोरी के रूप में स्टोर करें — पैटर्न से सीखें
> - महत्वपूर्ण त्रुटियों के लिए मनुष्यों को सूचित करें — उन्हें जानना चाहिए
> - सुंदरता से डिग्रेड करें — आंशिक कार्य क्रैश से बेहतर है
> - सर्किट ब्रेकर का उपयोग करें — विफल होते सेवा को घेरें नहीं
अगले कदम
- Errors API Reference
- Session Start Pattern
- Self-Healing Tests

────────────────────────────────────────────────────────────
# मेमोरी टैगिंग रणनीति
SUMMARY: प्रभावी खोज और फ़िल्टरिंग के लिए मेमोरीज़ को कैसे टैग करें — स्केल होने वाली टैगिंग प्रणाली।

मेमोरी टैगिंग रणनीति
टैग स्केलेबल मेमोरी रिट्रीवल का राज़ हैं। यह गाइड दिखाती है कि मेमोरीज़ को कैसे टैग करें ताकि सही समय पर सही मेमोरीज़ वापस आएँ।
टैग क्यों मायने रखते हैं
टैग के बिना, आपके पास सपाट फुल-टेक्स्ट खोज है। टैग के साथ, आपके पास संरचित नेविगेशन है:
[CODE BLOCK]
टैग सक्षम करते हैं:
- तेज़ फ़िल्टरिंग — 
- स्कोप्ड खोज — 
- समूहीकरण — किसी प्रोजेक्ट की सभी "mistake" मेमोरीज़ ढूँढें
- क्रॉस-रेफरेंसिंग — साझा टैग वाली मेमोरीज़ संबंधित हैं
टैगिंग स्कीमा
प्रोजेक्ट टैग
प्रोजेक्ट नामों को टैग के रूप में उपयोग करें:
[CODE BLOCK]
तकनीक टैग
तकनीक नामों का उपयोग करें:
[CODE BLOCK]
विषय टैग
विषय श्रेणियों का उपयोग करें:
[CODE BLOCK]
स्थिति टैग
स्थिति संकेतकों का उपयोग करें:
[CODE BLOCK]
प्रकार टैग
प्रकार संकेतकों का उपयोग करें:
[CODE BLOCK]
टैगिंग नियम
नियम 1: प्रति मेमोरी 2-5 टैग
बहुत कम टैग = खराब डिस्कवरेबिलिटी। बहुत अधिक = शोर।
[CODE BLOCK]
नियम 2: लोअरकेस, हाइफ़न युक्त
[CODE BLOCK]
नियम 3: सुसंगत शब्दावली का उपयोग करें
टैगिंग शब्दावली स्थापित करें और उस पर टिके रहें:
[CODE BLOCK]
नियम 4: खोज इरादे के साथ टैग करें
पूछें: "मैं इस मेमोरी को कैसे खोजूँगा?"
[CODE BLOCK]
पैटर्न
पैटर्न 1: प्रोजेक्ट + विषय
[CODE BLOCK]
खोज:  (सभी Synapse प्रोजेक्ट मेमोरीज़)
खोज:  (Synapse में डिप्लॉयमेंट मेमोरीज़)
पैटर्न 2: प्रकार + डोमेन
[CODE BLOCK]
खोज:  (सभी गलतियाँ)
खोज:  (डिप्लॉयमेंट गलतियाँ)
पैटर्न 3: पदानुक्रमित
किसी प्रोजेक्ट के भीतर उप-प्रोजेक्ट्स के लिए:
[CODE BLOCK]
खोज:  (सभी Synapse)
खोज:  (केवल docs उप-प्रोजेक्ट)
पैटर्न 4: स्थिति ट्रैकिंग
[CODE BLOCK]
सामान्य उपयोग के मामले
किसी प्रोजेक्ट के सभी निर्णय ढूँढें
[CODE BLOCK]
किसी डोमेन की सभी गलतियाँ ढूँढें
[CODE BLOCK]
सक्रिय कार्य ढूँढें
[CODE BLOCK]
किसी तकनीक के बारे में मेमोरीज़ ढूँढें
[CODE BLOCK]
टैग रखरखाव
आवधिक समीक्षा
[CODE BLOCK]
टैग मर्ज करना
यदि आपके पास असंगत टैग हैं ( और ), तो उन्हें मर्ज करें:
[CODE BLOCK]
सर्वोत्तम अभ्यास
> [!TIP]
> - शब्दावली जल्दी स्थापित करें — दिन 1 से सुसंगत टैग
> - खोज इरादे के लिए टैग करें — आप इसे बाद में कैसे ढूँढेंगे?
> - 2-5 टैग सही संतुलन है — बहुत कम या बहुत अधिक खराब है
> - लोअरकेस + हाइफ़न — ,  नहीं
> - आवधिक रूप से समीक्षा करें — डुप्लिकेट मर्ज करें, अप्रयुक्त हटाएँ
अगले कदम
- Memory Best Practices
- FTS5 Search
- Task-Driven Workflow

────────────────────────────────────────────────────────────
# सत्र शुरुआत पैटर्न
SUMMARY: वह कैनोनिकल सत्र-शुरुआत अनुक्रम जिसका पालन हर LLM एजेंट को करना चाहिए।

KEY CONTEXT:
ALWAYS at session start: 1) GET /memory/recall, 2) GET /chat/poll, 3) GET /mind/tasks?status=in_progress
Build system prompt from recall output.
Process unread chat messages before doing new work.
Resume any in_progress tasks before starting new ones.
Store new learnings as they happen — don't wait until session end.

सत्र शुरुआत पैटर्न
हर LLM एजेंट सत्र को इस कैनोनिकल स्टार्टअप अनुक्रम का पालन करना चाहिए। चरण छोड़ने से संदर्भ खो जाता है, संदेश छूट जाते हैं, और कार्य भूल जाते हैं।
पैटर्न
[CODE BLOCK]
कार्यान्वयन
चरण 1: सभी मेमोरीज़ रिकॉल करें
> [!CRITICAL]
> यह सबसे महत्वपूर्ण कॉल है। इसके बिना, आपके पास पिछले सत्रों की कोई मेमोरी नहीं है।
[CODE BLOCK]
सभी मेमोरीज़ का प्लेन-टेक्स्ट सारांश, प्राथमिकता अनुसार क्रमबद्ध लौटाता है।
चरण 2: अपठित चैट संदेशों के लिए पोल करें
[CODE BLOCK]
मानव से अपठित संदेश लौटाता है। स्वचालित रूप से उन्हें पढ़ा हुआ चिह्नित करता है।
चरण 3: प्रगति में कार्य जाँचें
[CODE BLOCK]
वे कार्य लौटाता है जिन पर आप पिछले सत्र में काम कर रहे थे।
चरण 4: संदर्भ बनाएँ
तीनों रिस्पॉन्स को अपने सिस्टम प्रॉम्प्ट में मिलाएँ:
[CODE BLOCK]
चरण 5: लंबित आइटम प्रोसेस करें
[CODE BLOCK]
संपूर्ण उदाहरण
[CODE BLOCK]
सामान्य गलतियाँ
> [!WARNING]
> - रिकॉल छोड़ना — आप बिना संदर्भ के शुरू करते हैं, पिछली गलतियाँ दोहराते हैं
> - चैट पोल भूलना — मानव के संदेश अनुत्तरित रह जाते हैं
> - सक्रिय कार्य अनदेखा करना — कार्य निष्पादन के बीच भूल जाते हैं
> - कुछ भी स्टोर न करना — सत्र कोई परसिस्टेंट मूल्य उत्पन्न नहीं करता
विविधताएँ
न्यूनतम पैटर्न (कम-संदर्भ LLMs)
छोटी संदर्भ विंडो वाले LLMs के लिए, पूर्ण रिकॉल छोड़ें:
[CODE BLOCK]
फिर आवश्यकतानुसार विशिष्ट विषयों के लिए खोजें:
[CODE BLOCK]
आक्रामक पैटर्न (लंबे समय तक चलने वाले एजेंट्स)
घंटों तक चलने वाले एजेंट्स के लिए, आवधिक पुनः-रिकॉल जोड़ें:
[CODE BLOCK]
अगले कदम
- Memory Tagging Strategy
- Task-Driven Workflow
- Chat Polling Pattern

────────────────────────────────────────────────────────────
# कार्य-संचालित वर्कफ़्लो
SUMMARY: Synapse tasks का उपयोग करके मल्टी-स्टेप LLM वर्कफ़्लो बनाएँ जो सत्रों में जीवित रहें।

कार्य-संचालित वर्कफ़्लो
Tasks सिर्फ todos नहीं हैं — वे परसिस्टेंट LLM वर्कफ़्लो की रीढ़ हैं। मल्टी-स्टेप कार्य के लिए tasks बनाकर, आप सत्रों में निरंतरता सुनिश्चित करते हैं और जो काम किया गया उसके लिए ऑडिट ट्रेल प्रदान करते हैं।
कार्य-संचालित क्यों?
Tasks के बिना:
- LLM हर सत्र की शुरुआत में अनिश्चित होता है कि क्या करना है
- मल्टी-स्टेप कार्य निष्पादन के बीच भूल जाते हैं
- क्या किया गया इसका कोई रिकॉर्ड नहीं
Tasks के साथ:
- LLM तुरंत प्रगति में कार्य फिर से शुरू करता है
- मल्टी-स्टेप कार्य सत्रों में जीवित रहते हैं
- सभी कार्य का इन-बिल्ट ऑडिट ट्रेल
पैटर्न
[CODE BLOCK]
कार्यान्वयन
चरण 1: मल्टी-स्टेप कार्य के लिए task बनाएँ
[CODE BLOCK]
चरण 2: task विवरण में प्रगति ट्रैक करें
[CODE BLOCK]
चरण 3: सत्रों में फिर से शुरू करें
[CODE BLOCK]
चरण 4: पूर्ण करें और संग्रहित करें
[CODE BLOCK]
पूर्ण उदाहरण: डिप्लॉय वर्कफ़्लो
[CODE BLOCK]
कार्य पदानुक्रम
जटिल कार्य के लिए, parent-child कार्य संबंधों का उपयोग करें:
[CODE BLOCK]
उप-कार्यों के लिए खोजें:
[CODE BLOCK]
स्थिति वर्कफ़्लो
[CODE BLOCK]
Pending
कार्य बनाया गया लेकिन शुरू नहीं हुआ। योजित कार्य के लिए उपयोग करें।
In Progress
वर्तमान में कार्य किया जा रहा है। प्रगति के साथ विवरण अपडेट करें।
Done
सफलतापूर्वक पूर्ण। विवरण में सारांश होना चाहिए।
Cancelled
त्यागा गया। विवरण में कारण होना चाहिए।
सर्वोत्तम अभ्यास
> [!TIP]
> - मल्टी-स्टेप कार्य के लिए tasks बनाएँ — सिंगल-स्टेप कार्य को task की आवश्यकता नहीं
> - प्रगति के साथ विवरण अपडेट करें — फिर से शुरू करना सक्षम बनाता है
> - सक्रिय कार्य के लिए high प्राथमिकता का उपयोग करें — रिकॉल में दिखाई देता है
> - पूर्ण होने पर tasks पूरे करें — उन्हें inprogress मत छोड़ें
> - पूर्णता सारांश को मेमोरी के रूप में स्टोर करें — दीर्घकालिक संदर्भ
सामान्य पैटर्न
पैटर्न: बग फिक्स वर्कफ़्लो
[CODE BLOCK]
पैटर्न: रिसर्च वर्कफ़्लो
[CODE BLOCK]
अगले कदम
- Session Start Pattern
- Chat Polling Pattern
- Error Recovery

## श्रेणी: सामान्य प्रश्न
अक्सर पूछे जाने वाले प्रश्न और सामान्य समस्याएँ।

────────────────────────────────────────────────────────────
# API FAQ
SUMMARY: सामान्य API प्रश्न — प्रमाणीकरण, रेट लिमिट, त्रुटि प्रबंधन, एंडपॉइंट खोज।

API FAQ
Synapse API के बारे में सामान्य प्रश्न।
मैं प्रमाणित कैसे करूँ?
दो विधियाँ:
1. Mind Key (डेटा एंडपॉइंट्स के लिए): 
2. JWT (खाता एंडपॉइंट्स के लिए): 
या क्वेरी पैरामीटर के माध्यम से (60 req/min सीमा): 
प्रमाणीकरण देखें।
Mind Key और JWT में क्या अंतर है?
- Mind Key: टैनेंट-स्कोप्ड, कभी समाप्त नहीं होता, memory/chat/tasks डेटा के लिए
- JWT: उपयोगकर्ता-स्कोप्ड, 7-दिन समाप्ति, खाता/mind प्रबंधन के लिए
Mind Key vs JWT देखें।
मुझे 401 Unauthorized क्यों मिल रहा है?
सामान्य कारण:
1.  हेडर गायब
2. अमान्य Mind Key (सत्यापित करें कि यह  से शुरू होता है)
3. Mind Key आवश्यक होने पर JWT का उपयोग (या इसके विपरीत)
4. Mind Key रद्द कर दी गई
समाधान: अपने टोकन को सत्यापित करें। प्रमाणीकरण देखें।
मुझे 404 Not Found क्यों मिल रहा है?
आपने गलत एंडपॉइंट पाथ का उपयोग किया। Synapse में केवल  में सूचीबद्ध पाथ हैं।
समाधान: सभी वैध पाथ देखने के लिए  कॉल करें। अनुमान न लगाएँ।
मुझे 429 Too Many Requests क्यों मिल रहा है?
आप  क्वेरी पैरामीटर प्रमाणीकरण का उपयोग कर रहे हैं, जो 60/min तक सीमित है।
समाधान:  हेडर पर स्विच करें (कोई रेट लिमिट नहीं)।
रेट लिमिट देखें।
मैं सभी एंडपॉइंट्स की सूची कैसे बनाऊँ?
[CODE BLOCK]
मुझे सही एंडपॉइंट कैसे मिले?
1. मशीन-पठनीय सूची के लिए  जाँचें
2. पूर्ण API दस्तावेज़ के लिए  जाँचें
3. दस्तावेज़ीकरण सिस्टम के लिए  ब्राउज़ करें
4. OpenAPI 3.0 विशेषता के लिए  का उपयोग करें
क्या मैं POST के बजाय GET का उपयोग कर सकता हूँ?
कुछ POST एंडपॉइंट्स में URL-केवल टूल्स के लिए GET समकक्ष हैं:
-  ↔ 
-  ↔ 
-  ↔ 
उपलब्ध GET वेरिएंट्स के लिए  जाँचें।
मैं त्रुटियों को कैसे संभालूँ?
सभी त्रुटियाँ JSON लौटाती हैं:
[CODE BLOCK]
त्रुटियाँ और त्रुटि प्रबंधन देखें।
अनुरोध बॉडी सीमा क्या है?
10 MB। बड़े payloads (जैसे फ़ाइल अपलोड) के लिए, multipart एंडपॉइंट्स का उपयोग करें।
क्या API CORS का समर्थन करता है?
हाँ। सभी एंडपॉइंट्स लौटाते हैं:
[CODE BLOCK]
क्या कोई SDK है?
हाँ:
- Node.js: 
- MCP: 
विवरण के लिए API Overview देखें।
मैं पेजिनेशन कैसे करूँ?
 और  का उपयोग करें:
[CODE BLOCK]
डिफ़ॉल्ट सीमा: 100। अधिकतम: 500।
क्या मैं मेमोरीज़ को श्रेणी या टैग से फ़िल्टर कर सकता हूँ?
हाँ:
[CODE BLOCK]
मैं मेमोरीज़ कैसे खोजूँ?
दो तरीके:
1. FTS5 कीवर्ड खोज: 
2. सिमेंटिक खोज: 
FTS5 Search और सिमेंटिक खोज देखें।
मैं मेमोरी कैसे अपडेट करूँ?
समान  +  के साथ POST  — मौजूदा मेमोरी अपडेट होती है, डुप्लिकेट नहीं होती।
[CODE BLOCK]
मैं मेमोरी कैसे हटाऊँ?
[CODE BLOCK]
क्या मैं बल्क हटा सकता हूँ?
हाँ:
[CODE BLOCK]
अगले कदम
- API Overview
- त्रुटियाँ और त्रुटि प्रबंधन
- प्रमाणीकरण

────────────────────────────────────────────────────────────
# सामान्य FAQ
SUMMARY: Synapse के बारे में सामान्य प्रश्न — यह क्या है, कैसे काम करता है, किसके लिए है।

सामान्य FAQ
Synapse के बारे में सामान्य प्रश्न।
Synapse क्या है?
Synapse LLM एजेंट्स के लिए एक स्थायी मेमोरी API है। यह आपके AI सहायक को एक स्थायी, क्वेरी करने योग्य मस्तिष्क देता है जो सत्रों में बना रहता है। चैट बंद होने पर सब कुछ भूलने के बजाय, LLM एक सरल HTTP API के माध्यम से मेमोरीज़ स्टोर और पुनः प्राप्त करता है।
अधिक जानें: Synapse क्या है?
Synapse किसके लिए है?
- LLM एजेंट डेवलपर्स जिन्हें स्थायी स्थिति चाहिए
- पावर उपयोगकर्ता कस्टम एजेंट्स के साथ लोकल LLM चलाते हैं
- टीमें साझा मेमोरी के साथ AI सहायक बना रही हैं
- ऑटोमेशन इंजीनियर सत्रों में LLM कॉल्स जोड़ रहे हैं
क्या Synapse मुफ़्त है?
Synapse <https://synapse.schaefer.zone> पर होस्ट है और व्यक्तिगत उपयोग के लिए मुफ़्त है। सेल्फ-होस्टिंग के लिए, repo देखें।
Synapse ChatGPT Memory से कैसे भिन्न है?
| फ़ीचर | ChatGPT Memory | Synapse |
|---------|---------------|---------|
| स्टोरेज | OpenAI सर्वर | आपका सर्वर |
| API एक्सेस | नहीं | हाँ (REST + MCP) |
| मल्टी-टैनेंट | नहीं | हाँ (minds) |
| कस्टम श्रेणियाँ | नहीं | हाँ (8 श्रेणियाँ) |
| फुल-टेक्स्ट खोज | सीमित | FTS5 + सिमेंटिक |
| सेल्फ-होस्टेबल | नहीं | हाँ |
कौन से LLM Synapse के साथ काम करते हैं?
कोई भी LLM जो HTTP कॉल कर सकता है या MCP का उपयोग कर सकता है:
- Claude (Anthropic) — MCP या सीधे API के माध्यम से
- GPT-4 / GPT-3.5 (OpenAI) — फ़ंक्शन कॉलिंग + API के माध्यम से
- Gemini (Google) — फ़ंक्शन कॉलिंग + API के माध्यम से
- Llama / Mistral (लोकल) — कस्टम इंटीग्रेशन के माध्यम से
- कोई भी LLM Synapse MCP server के माध्यम से
क्या मुझे Synapse स्वयं होस्ट करना होगा?
नहीं। <https://synapse.schaefer.zone> पर होस्टेड संस्करण सार्वजनिक उपयोग के लिए उपलब्ध है। सेल्फ-होस्टिंग वैकल्पिक है (निजता, अनुकूलन, या एयर-गैप्ड परिवेश के लिए)।
मैं कितना डेटा स्टोर कर सकता हूँ?
होस्टेड संस्करण पर कोई कठोर सीमा नहीं है। सामान्य उपयोग:
- प्रति mind 100-1000 मेमोरीज़
- प्रति मेमोरी 1-10 KB (content फ़ील्ड)
- कुल: प्रति mind 10 MB
बड़े पैमाने के लिए, सेल्फ-होस्ट करें।
क्या मेरा डेटा निजी है?
हाँ। प्रत्येक mind अलग है (मल्टी-टैनेंसी देखें)। अन्य उपयोगकर्ता आपका डेटा नहीं देख सकते। होस्टिंग प्रदाता (Schäfer Services) के पास एक्सेस है लेकिन वह उपयोगकर्ता डेटा देखता नहीं है।
अधिकतम निजता के लिए, सेल्फ-होस्ट करें।
क्या मैं अपना डेटा निर्यात कर सकता हूँ?
हाँ। सभी मेमोरीज़ को JSON के रूप में निर्यात करने के लिए  का उपयोग करें। बैकअप और रिस्टोर देखें।
यदि मैं अपनी Mind Key खो दूँ तो क्या होगा?
Mind Keys निर्माण पर केवल एक बार दिखाई जाती हैं। खो जाने पर:
1. JWT प्राप्त करने के लिए अपने ईमेल/पासवर्ड से लॉगिन करें
2.  के माध्यम से नया mind बनाएँ
3. नई Mind Key सहेजें
4. (वैकल्पिक) पुराना mind  से हटाएँ
आप उस mind की मेमोरीज़ पुनः प्राप्त नहीं कर सकते जिसकी कुंजी खो गई है।
क्या कई LLM एजेंट्स एक mind साझा कर सकते हैं?
हाँ। एक ही Mind Key का उपयोग करने वाले सभी एजेंट्स उस mind का डेटा साझा करते हैं। समन्वित मल्टी-एजेंट कार्य के लिए, मल्टी-एजेंट समन्वय देखें।
क्या Synapse ऑफ़लाइन काम करता है?
नहीं, Synapse को सर्वर (होस्टेड या सेल्फ-होस्टेड) तक इंटरनेट कनेक्शन की आवश्यकता है। ऑफ़लाइन LLMs के लिए, Synapse लोकल चलाएँ।
मेमोरी खोज कितनी तेज़ है?
- FTS5 कीवर्ड खोज: 1000 मेमोरीज़ के लिए < 10ms
- सिमेंटिक खोज: 1000 मेमोरीज़ के लिए 50-100ms
- पूर्ण रिकॉल: 1000 मेमोरीज़ के लिए < 50ms
विवरण के लिए FTS5 Search देखें।
क्या मैं LLM के बिना Synapse का उपयोग कर सकता हूँ?
हाँ। Synapse एक सामान्य मेमोरी API है। आप इसे किसी भी एप्लिकेशन से उपयोग कर सकते हैं जो श्रेणियों और टैग्स के साथ स्थायी, खोज योग्य key-value स्टोरेज से लाभान्वित होता है।
अगले कदम
- Synapse क्या है?
- Quick Start
- API FAQ

────────────────────────────────────────────────────────────
# MCP FAQ
SUMMARY: MCP इंटीग्रेशन के बारे में सामान्य प्रश्न — टूल्स, ट्रांसपोर्ट, ट्रबलशूटिंग।

MCP FAQ
Synapse MCP server के बारे में सामान्य प्रश्न।
MCP क्या है?
MCP (Model Context Protocol) LLM-टूल इंटीग्रेशन के लिए Anthropic द्वारा एक खुला मानक है। प्रॉम्प्ट्स में API दस्तावेज़ पेस्ट करने के बजाय, आप एक MCP server के साथ टूल्स पंजीकृत करते हैं, और LLM उन्हें मूल फ़ंक्शन्स के रूप में कॉल करता है।
MCP क्या है? देखें।
Synapse MCP कितने टूल्स एक्सपोज़ करता है?
12 श्रेणियों में 79 टूल्स: memory, chat, scheduler, tasks, scripts, computers, push, user, utility, visualization, sharing, webhooks, browser।
पूरी सूची के लिए MCP क्या है? देखें।
कौन से MCP क्लाइंट्स समर्थित हैं?
- Claude Desktop (macOS, Windows)
- Claude Code (terminal)
- Cursor (IDE)
- Continue.dev (VS Code, JetBrains)
- Cline (VS Code)
- कोई भी MCP-संगत क्लाइंट
कॉन्फ़िग उदाहरणों के लिए Claude Desktop सेटअप देखें।
कौन से ट्रांसपोर्ट समर्थित हैं?
1. stdio (लोकल, डेस्कटॉप के लिए अनुशंसित)
2. HTTP/SSE (रिमोट, मल्टी-टैनेंट)
3. WebSocket (मोबाइल, उच्च-मात्रा)
मैं Claude Desktop कैसे कॉन्फ़िगर करूँ?
 संपादित करें:
[CODE BLOCK]
Claude Desktop सेटअप देखें।
Claude Desktop में टूल्स क्यों दिखाई नहीं देते?
1. Claude Desktop पूरी तरह रीस्टार्ट करें (macOS पर Cmd+Q)
2. जाँचें कॉन्फ़िग फ़ाइल वैध JSON है
3. सत्यापित करें Node.js 18+ इंस्टॉल है
4. MCP लॉग जाँचें: 
MCP ट्रबलशूटिंग देखें।
मैं भिन्न mind का उपयोग कैसे करूँ?
अपने MCP config में  बदलें और क्लाइंट रीस्टार्ट करें।
कई minds के लिए, भिन्न Mind Keys के साथ कई MCP server इंस्टेंस चलाएँ।
क्या मैं सीमित कर सकता हूँ कि कौन से टूल्स एक्सपोज़ हों?
हाँ, Tool Profiles का उपयोग करें:
- : 8 कम्पोजिट टूल्स (500 टोकन)
- : 25 टूल्स (2,500 टोकन)
- : 119 टूल्स (8,250 टोकन, डिफ़ॉल्ट)
 env var या  हेडर के माध्यम से सेट करें।
मैं MCP समस्याओं को कैसे डीबग करूँ?
1. MCP server मैन्युअली चलाएँ: 
2. क्लाइंट लॉग जाँचें (क्लाइंट अनुसार भिन्न)
3. Mind Key काम करता है सत्यापित करें: 
4. Synapse स्वास्थ्य जाँचें: 
MCP ट्रबलशूटिंग देखें।
क्या MCP server मुफ़्त है?
हाँ। npm पैकेज  ओपन सोर्स है।  पर होस्टेड MCP server सार्वजनिक उपयोग के लिए मुफ़्त है।
क्या मैं MCP server सेल्फ-होस्ट कर सकता हूँ?
हाँ:
[CODE BLOCK]
MCP सीधे API कॉल्स से कैसे भिन्न है?
| पहलू | सीधे API | MCP |
|--------|-----------|-----|
| LLM को जानना चाहिए | URLs, हेडर, प्रमाणीकरण | केवल टूल नाम |
| प्रमाणीकरण हैंडलिंग | मैन्युअल | स्वचालित (env var) |
| टूल खोज | /endpoints पढ़ें | MCP प्रोटोकॉल के माध्यम से स्वचालित |
| त्रुटि प्रबंधन | मैन्युअल | मानकीकृत |
| के लिए सर्वोत्तम | कस्टम इंटीग्रेशन | LLM एजेंट्स |
क्या मैं अपना स्वयं का MCP क्लाइंट बना सकता हूँ?
हाँ। आधिकारिक MCP SDK का उपयोग करें:
- TypeScript: 
- Python: 
कस्टम MCP क्लाइंट देखें।
मैं MCP बग की रिपोर्ट कैसे करूँ?
Issue खोलें: <https://gitlab.com/schaefer-services/synapse-mcp/-/issues>
शामिल करें:
- MCP server संस्करण
- क्लाइंट नाम और संस्करण
- ऑपरेटिंग सिस्टम
- प्रासंगिक लॉग
- पुनरुत्पादन के चरण
अगले कदम
- MCP क्या है?
- Claude Desktop सेटअप
- MCP ट्रबलशूटिंग

────────────────────────────────────────────────────────────
# ट्रबलशूटिंग FAQ
SUMMARY: सामान्य Synapse समस्याओं के समाधान — प्रमाणीकरण, नेटवर्क, डेटा, परिनियोजन।

ट्रबलशूटिंग FAQ
सामान्य Synapse समस्याओं के समाधान।
मैं लॉगिन नहीं कर पा रहा
लक्षण
-  401 लौटाता है
- "Invalid email or password"
समाधान
1. ईमेल सही है सत्यापित करें — केस संवेदनशील
2. पासवर्ड जाँचें — न्यूनतम 6 अक्षर
3. पहले पंजीकरण करें यदि आपके पास खाता नहीं है: 
4. पासवर्ड रीसेट करें (यदि SMTP कॉन्फ़िगर है) वेब UI के माध्यम से
मैंने अपनी Mind Key खो दी
लक्षण
- मेमोरीज़ एक्सेस नहीं कर सकते
- Mind Key हटा दी गई/खो गई
समाधान
Mind Keys पुनः प्राप्त नहीं की जा सकतीं। आपको ये करना होगा:
1. JWT प्राप्त करने के लिए लॉगिन करें: 
2. Minds की सूची बनाएँ:  (JWT के साथ)
3. नया mind बनाएँ: 
4. नई Mind Key सहेजें
5. (वैकल्पिक) पुराना mind हटाएँ: 
पुराने mind का डेटा खो गया जब तक आप Mind Key न ढूँढ लें।
API कॉल्स 401 लौटाते हैं
लक्षण
- सभी API कॉल्स 401 Unauthorized लौटाते हैं
- "Mind Key fehlt oder ungültig"
समाधान
1. हेडर प्रारूप सत्यापित करें: 
2. जाँचें Mind Key  से शुरू होती है (न कि  जो JWT है)
3. सीधे परीक्षण करें:
   [CODE BLOCK]
4. Mind Key रद्द हो सकती है — नया mind बनाएँ
प्रमाणीकरण देखें।
API कॉल्स 404 लौटाते हैं
लक्षण
- 404 Not Found
- "Route not found"
समाधान
> [!CRITICAL]
> एंडपॉइंट पाथ का अनुमान न लगाएँ। केवल  में पाथ मौजूद हैं।
1. वैध एंडपॉइंट्स जाँचें: 
2. URL सटीक तुलना करें — केस संवेदनशील, कोई अनुगामी स्लैश नहीं
3. HTTP विधि जाँचें —  बनाम  भिन्न हैं
API कॉल्स 429 लौटाते हैं
लक्षण
- 429 Too Many Requests
- "Rate limit exceeded"
समाधान
1. हेडर प्रमाणीकरण पर स्विच करें (कोई रेट लिमिट नहीं):
   [CODE BLOCK]
2. यदि आपको  उपयोग करना ही है तो  सेकंड प्रतीक्षा करें
रेट लिमिट देखें।
मेमोरी खोज कोई परिणाम नहीं लौटाती
लक्षण
-  खाली लौटाता है
- जानते हैं मेमोरीज़ मौजूद हैं
समाधान
1. मेमोरीज़ मौजूद हैं सत्यापित करें: 
2. खोज सिंटैक्स जाँचें — FTS5 की विशिष्ट सिंटैक्स है
3. सरल क्वेरी आज़माएँ —  के बजाय 
4. वैचारिक क्वेरीज़ के लिए सिमेंटिक खोज का उपयोग करें: 
FTS5 Search देखें।
मेमोरीज़ बनी नहीं रह रहीं
लक्षण
- POST /memory success लौटाता है
- GET /memory/recall उन्हें नहीं दिखाता
समाधान
1. समान Mind Key सत्यापित करें — भिन्न कुंजी = भिन्न minds
2. प्रतिक्रिया जाँचें — POST  लौटाता है
3. /memory/recall (टेक्स्ट) के बजाय GET /memory (JSON सूची) आज़माएँ
4. फ़िल्टर जाँचें —  या  उन्हें छिपा सकते हैं
Claude Desktop में टूल्स दिखाई नहीं दे रहे
लक्षण
- Claude Desktop 0 टूल्स दिखाता है
- कोई 🔌 आइकन नहीं
समाधान
1. Claude Desktop पूरी तरह रीस्टार्ट करें (Cmd+Q)
2. सत्यापित करें कॉन्फ़िग फ़ाइल वैध JSON है
3. Node.js 18+ इंस्टॉल जाँचें
4. MCP मैन्युअली चलाएँ: 
5. लॉग जाँचें: 
MCP ट्रबलशूटिंग देखें।
Synapse ऑफ़लाइन है
लक्षण
- synapse.schaefer.zone तक नहीं पहुँच सकते
- curl समय समाप्त होता है
समाधान
1. अपना इंटरनेट जाँचें — किसी अन्य साइट का प्रयास करें
2. Synapse स्वास्थ्य जाँचें: 
3. प्रतीक्षा करें — अस्थायी आउटेज या परिनियोजन हो सकता है
4. स्टेटस पृष्ठ जाँचें (यदि उपलब्ध हो)
सेल्फ-होस्टेड के लिए: Docker कंटेनर स्थिति, डेटाबेस कनेक्शन जाँचें।
डेटाबेस त्रुटियाँ
लक्षण
- 500 Internal Server Error
- "Database connection failed"
समाधान
सेल्फ-होस्टेड के लिए:
1. PostgreSQL चल रहा है जाँचें: 
2. env में DATABASEURL जाँचें
3. माइग्रेशन जाँचें: 
4. डिस्क स्थान जाँचें: 
होस्टेड के लिए: सहायता को रिपोर्ट करें।
Webhook सक्रिय नहीं हो रहा
लक्षण
- Webhook पंजीकृत किया लेकिन कॉलबैक नहीं मिल रहे
- आपके URL पर कोई POST नहीं
समाधान
1. URL पहुँच योग्य है सत्यापित करें: 
2. events फ़िल्टर जाँचें —  सभी मेमोरी घटनाओं से मेल खाता है
3. webhook परीक्षण: 
4. webhook सक्षम है जाँचें: 
5. SSL सत्यापित करें — Synapse को webhook URLs के लिए वैध HTTPS चाहिए
Webhooks API देखें।
Cron कार्य नहीं चल रहा
लक्षण
- Cron कार्य बनाया लेकिन सक्रिय नहीं हो रहा
-  अपडेट नहीं हो रहा
समाधान
1. शेड्यूल सिंटैक्स जाँचें — वैध 5-फ़ील्ड cron या पूर्णांक सेकंड होना चाहिए
2. एंडपॉइंट अनुमत है सत्यापित करें — http(s) होना चाहिए, कोई निजी IP नहीं
3. कार्य सक्षम है जाँचें: 
4. अगले शेड्यूल किए गए समय की प्रतीक्षा करें — cron तुरंत नहीं होता
Cron और Scheduler देखें।
और सहायता चाहिए?
1. मौजूदा दस्तावेज़ जाँचें: <https://synapse.schaefer.zone/docs>
2. दस्तावेज़ खोजें: 
3. Issue खोलें: <https://gitlab.com/schaefer-services/synapse/-/issues>
4. संपर्क:  पृष्ठ देखें
अगले कदम
- त्रुटियाँ और त्रुटि प्रबंधन
- API FAQ
- MCP ट्रबलशूटिंग