# मेमोरी टैगिंग रणनीति

टैग स्केलेबल मेमोरी रिट्रीवल का राज़ हैं। यह गाइड दिखाती है कि मेमोरीज़ को कैसे टैग करें ताकि सही समय पर सही मेमोरीज़ वापस आएँ।

## टैग क्यों मायने रखते हैं

टैग के बिना, आपके पास सपाट फुल-टेक्स्ट खोज है। टैग के साथ, आपके पास संरचित नेविगेशन है:

```bash
# Without tags: search everything
GET /memory/search?q=docker

# With tags: filter by project + technology
GET /memory/search?q=deployment&tag=synapse&tag=docker
```

टैग सक्षम करते हैं:

- **तेज़ फ़िल्टरिंग** — `GET /memory/by-tag?tag=production`
- **स्कोप्ड खोज** — `?q=auth&tag=project-x`
- **समूहीकरण** — किसी प्रोजेक्ट की सभी "mistake" मेमोरीज़ ढूँढें
- **क्रॉस-रेफरेंसिंग** — साझा टैग वाली मेमोरीज़ संबंधित हैं

## टैगिंग स्कीमा

### प्रोजेक्ट टैग

प्रोजेक्ट नामों को टैग के रूप में उपयोग करें:

```
synapse, synapse-mcp, synapse-chat, synapse-sdk
```

### तकनीक टैग

तकनीक नामों का उपयोग करें:

```
docker, kubernetes, postgres, fastify, react, typescript
```

### विषय टैग

विषय श्रेणियों का उपयोग करें:

```
deployment, ci-cd, auth, database, frontend, backend, security
```

### स्थिति टैग

स्थिति संकेतकों का उपयोग करें:

```
active, completed, blocked, deprecated
```

### प्रकार टैग

प्रकार संकेतकों का उपयोग करें:

```
decision, mistake, pattern, reference, todo
```

## टैगिंग नियम

### नियम 1: प्रति मेमोरी 2-5 टैग

बहुत कम टैग = खराब डिस्कवरेबिलिटी। बहुत अधिक = शोर।

```json
// Good: 3 relevant tags
{ "tags": ["synapse", "deployment", "docker"] }

// Bad: 1 tag (too narrow)
{ "tags": ["synapse"] }

// Bad: 10 tags (noise)
{ "tags": ["synapse", "deployment", "docker", "vps1", "2026", "june", "ssh", "git", "main", "production"] }
```

### नियम 2: लोअरकेस, हाइफ़न युक्त

```
✅ ci-cd, api-key, mind-key
❌ CI-CD, APIKey, MindKey
```

### नियम 3: सुसंगत शब्दावली का उपयोग करें

टैगिंग शब्दावली स्थापित करें और उस पर टिके रहें:

```
# Project vocabulary
synapse, synapse-mcp, synapse-chat

# NOT: synapse_project, synapseProject, SYNAPSE
```

### नियम 4: खोज इरादे के साथ टैग करें

पूछें: "मैं इस मेमोरी को कैसे खोजूँगा?"

```json
// Storing a deployment decision
{
  "content": "Decided to use Docker Swarm for Synapse deployment",
  "tags": ["synapse", "deployment", "docker", "swarm", "decision"]
}

// You'll likely search: ?q=docker+swarm or ?tag=deployment
```

## पैटर्न

### पैटर्न 1: प्रोजेक्ट + विषय

```json
{ "tags": ["synapse", "deployment"] }
{ "tags": ["synapse", "auth"] }
{ "tags": ["synapse-mcp", "tools"] }
```

खोज: `?tag=synapse` (सभी Synapse प्रोजेक्ट मेमोरीज़)
खोज: `?tag=synapse&q=deployment` (Synapse में डिप्लॉयमेंट मेमोरीज़)

### पैटर्न 2: प्रकार + डोमेन

```json
{ "tags": ["mistake", "deployment"] }
{ "tags": ["decision", "database"] }
{ "tags": ["pattern", "auth"] }
```

खोज: `?tag=mistake` (सभी गलतियाँ)
खोज: `?tag=mistake&q=deployment` (डिप्लॉयमेंट गलतियाँ)

### पैटर्न 3: पदानुक्रमित

किसी प्रोजेक्ट के भीतर उप-प्रोजेक्ट्स के लिए:

```json
{ "tags": ["synapse", "synapse-docs", "markdown"] }
{ "tags": ["synapse", "synapse-mcp", "mcp"] }
{ "tags": ["synapse", "synapse-admin", "ui"] }
```

खोज: `?tag=synapse` (सभी Synapse)
खोज: `?tag=synapse-docs` (केवल docs उप-प्रोजेक्ट)

### पैटर्न 4: स्थिति ट्रैकिंग

```json
// Active project
{ "tags": ["synapse", "active"], "priority": "high" }

// Completed project
{ "tags": ["synapse-v1", "completed"], "priority": "low" }

// Blocked
{ "tags": ["synapse-v2", "blocked"], "priority": "high" }
```

## सामान्य उपयोग के मामले

### किसी प्रोजेक्ट के सभी निर्णय ढूँढें

```bash
curl -H "Authorization: Bearer $KEY" \
     ".../memory/search?q=decision&tag=synapse"
```

### किसी डोमेन की सभी गलतियाँ ढूँढें

```bash
curl -H "Authorization: Bearer $KEY" \
     ".../memory/search?q=mistake&tag=deployment"
```

### सक्रिय कार्य ढूँढें

```bash
curl -H "Authorization: Bearer $KEY" \
     ".../memory/by-tag?tag=active"
```

### किसी तकनीक के बारे में मेमोरीज़ ढूँढें

```bash
curl -H "Authorization: Bearer $KEY" \
     ".../memory/search?q=postgres+performance&tag=database"
```

## टैग रखरखाव

### आवधिक समीक्षा

```python
# Find rarely-used tags (candidates for cleanup)
tags = requests.get(f"{URL}/memory/tags",
    headers={"Authorization": f"Bearer {KEY}"}).json()

for tag, count in tags.items():
    if count < 2:
        print(f"Rare tag: {tag} ({count} memories)")
```

### टैग मर्ज करना

यदि आपके पास असंगत टैग हैं (`docker` और `Docker`), तो उन्हें मर्ज करें:

```python
# Find all memories with "Docker" tag
mems = requests.get(f"{URL}/memory/by-tag?tag=Docker",
    headers={"Authorization": f"Bearer {KEY}"}).json()

# Update each to use "docker" instead
for mem in mems["results"]:
    tags = [t.lower() for t in mem["tags"]]
    update_memory(mem["id"], tags=list(set(tags)))
```

## सर्वोत्तम अभ्यास

> [!TIP]
> - **शब्दावली जल्दी स्थापित करें** — दिन 1 से सुसंगत टैग
> - **खोज इरादे के लिए टैग करें** — आप इसे बाद में कैसे ढूँढेंगे?
> - **2-5 टैग सही संतुलन है** — बहुत कम या बहुत अधिक खराब है
> - **लोअरकेस + हाइफ़न** — `ci-cd`, `CI/CD` नहीं
> - **आवधिक रूप से समीक्षा करें** — डुप्लिकेट मर्ज करें, अप्रयुक्त हटाएँ

## अगले कदम

- [Memory Best Practices](/docs/guides/memory-best-practices)
- [FTS5 Search](/docs/concepts/fts5-search)
- [Task-Driven Workflow](/docs/llm-cookbook/task-driven-workflow)