---
title: '@runic-labs/cache'
description: सिग्नेचर-कुंजीबद्ध आर्टिफैक्ट स्टोरेज — इन-मेमोरी और फ़ाइल-आधारित।
sidebar:
  order: 4
---
`@runic-labs/cache` एक सामान्यीकृत निर्णय सिग्नेचर को उससे निर्मित आर्टिफैक्ट से मैप करता है। अधिकांश इंटीग्रेशन को इस पैकेज की सीधे आवश्यकता नहीं होती — `@runic-labs/sdk` इसे रैप करता है — लेकिन यह कस्टम स्टोर सेटअप या कैश के आंतरिक हिस्सों की जाँच के लिए उपयोगी है।

```package-install
npm i @runic-labs/cache
```

## `signature(decision)`

एक `Decision` को सामान्यीकृत करता है और उसका SHA-256 सिग्नेचर लौटाता है। `params` में ऑब्जेक्ट कुंजियों को पुनरावर्ती रूप से सॉर्ट किया जाता है, इसलिए कुंजी क्रम कभी हैश को प्रभावित नहीं करता। पूरे एल्गोरिदम के लिए [यह कैसे काम करता है](/how-it-works) देखें।

```ts
import { signature } from "@runic-labs/cache";

signature({ intent: "summarize_pr", params: { repo: "acme/widgets", pr: 482 } });
// => same hash regardless of param key order
```

## `createCache(store?)`

```ts
import { createCache, FileCacheStore, defaultCacheFilePath } from "@runic-labs/cache";

const cache = createCache(new FileCacheStore({ filePath: defaultCacheFilePath() }));
```

यदि कोई स्टोर पास नहीं किया जाता, तो डिफ़ॉल्ट रूप से `.runic/cache.json` (या `$RUNIC_HOME/cache.json`) के अंतर्गत `FileCacheStore` उपयोग होता है।

| Prop | Type | Default | Description |
| - | - | - | - |
| `get(decision)?` | `CachedEntry \| null` | - | Looks up a decision. Bumps hit stats on a hit. |
| `set(decision, artifact, meta)?` | `CachedEntry` | - | Stores an artifact for a decision. meta = { tokensSpent }. |
| `list()?` | `CachedEntry[]` | - | All entries currently in the store. |
| `clear()?` | `void` | - | Removes all entries. |

## स्टोरेज बैकएंड

### `MemoryCacheStore`

केवल इन-मेमोरी, प्रक्रिया के जीवनकाल तक रहता है। इसका उपयोग बेंचमार्क और परीक्षण, दोनों द्वारा किया जाता है, इसलिए रन स्व-निहित और दोहराने योग्य होते हैं।

```ts
import { createCache, MemoryCacheStore } from "@runic-labs/cache";

const cache = createCache(new MemoryCacheStore({ staleAfterMs: 60_000 }));
```

### `FileCacheStore`

JSON फ़ाइल में स्थायी रूप से सहेजता है, ताकि CLI प्रक्रिया और एजेंट प्रक्रिया किसी चल रहे सर्वर के बिना एक ही कैश पढ़ सकें।

```ts
import { createCache, FileCacheStore } from "@runic-labs/cache";

const cache = createCache(new FileCacheStore({ filePath: "./my-agent/.runic/cache.json" }));
```

किसी भ्रष्ट या आंशिक रूप से लिखी गई फ़ाइल को त्रुटि फेंकने के बजाय खाली माना जाता है — लिखने के बीच में होने वाला क्रैश अगली रीड को कभी बाधित नहीं करना चाहिए।

## अपना `CacheStore` लागू करना

दोनों अंतर्निहित स्टोर एक ही छोटे इंटरफ़ेस को लागू करते हैं, इसलिए Redis- या SQLite-आधारित स्टोर एक ड्रॉप-इन प्रतिस्थापन है:

```ts
interface CacheStore {
  get(signature: string): CachedEntry | null;
  set(signature: string, artifact: unknown, meta: { tokensSpent: number }): CachedEntry;
  touch(signature: string): CachedEntry | null;
  list(): CachedEntry[];
  clear(): void;
}
```

हर कैश हिट पर `hitCount` और `lastUsedAt` बढ़ाने के लिए `touch` को आंतरिक रूप से कॉल किया जाता है — इसे अपने चुने हुए बैकिंग स्टोर के विरुद्ध रीड-मॉडिफ़ाई-राइट के रूप में लागू करें।

## आगे

- [लेजर](/ledger) — मिलान करने वाली खर्च/बचत लेखांकन परत
- [SDK](/sdk) — वह दो-फ़ंक्शन अनुबंध जिसका अधिकांश इंटीग्रेशन वास्तव में उपयोग करते हैं