> ## Documentation Index
> Fetch the complete documentation index at: https://forgekit-docs-mintlify-7cd64f48.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Forge: AI कोडिंग एजेंट्स के लिए संज्ञानात्मक सब्सट्रेट

> Forge वह संज्ञानात्मक सब्सट्रेट है जो हर स्टेटलेस मॉडल में गायब है — मेमोरी, दूरदर्शिता और गार्डरेल्स — जो हर AI कोडिंग एजेंट को नेटिव कॉन्फ़िग के रूप में मिलता है।

**हर AI कोडिंग एजेंट के लिए एक ही मस्तिष्क।** एक बड़ा भाषा मॉडल स्टेटलेस होता है: एक
कॉन्टेक्स्ट विंडो, जो हर कॉल पर मिटा दी जाती है। उसके पास आपकी टीम ने जो सीखा उसकी
कोई मेमोरी नहीं है, किसी एडिट से क्या टूटेगा इसका कोई पूर्वाभास नहीं है, और कोई
प्रवर्तित गार्डरेल्स नहीं हैं। Forge (`@codewithjuber/forgekit`) वही **संज्ञानात्मक
सब्सट्रेट** है — वह परत जो मॉडल द्वारा कोड एडिट करने से *पहले* चलती है, और साक्ष्य-संदर्भित,
कंटेंट-एड्रेस्ड मेमोरी (जिसे हम "प्रूफ-कैरीइंग मेमोरी" कहते हैं), ह्यूरिस्टिक प्रभाव-पूर्वाभास,
और प्रवर्तित गार्डरेल्स प्रदान करती है — और एक **क्रॉस-टूल कॉन्फ़िग कंपाइलर** जो
उस मस्तिष्क को एक ही बार में हर टूल में नेटिव कॉन्फ़िग के रूप में पहुँचाता है। Claude Code
सबसे गहराई से परखा गया इंटीग्रेशन है; बाकी टूल्स को नेटिव कॉन्फ़िग और MCP टूल्स
मिलते हैं जिनका वास्तविक अभ्यास कम है।

<CardGroup cols={3}>
  <Card title="मेमोरी" icon="brain">
    प्रूफ-कैरीइंग मेमोरी जो सत्रों और टीम-साथियों के बीच बनी रहती है। हर सबक,
    तथ्य, और सत्यापित पुनरुपयोग एक ऐसा दावा है जो अपना साक्ष्य स्वयं वहन करता है।
  </Card>

  <Card title="दूरदर्शिता" icon="radar">
    किसी एडिट की ब्लास्ट रेडियस — कोड ग्राफ़ से पढ़ी गई उन फ़ाइलों का समूह जिन पर
    प्रभाव पड़ने की भविष्यवाणी है, उन युग्मित फ़ाइलों सहित जिनका नाम आपने नहीं लिया।
  </Card>

  <Card title="गार्डरेल्स" icon="shield">
    डिटरमिनिस्टिक हुक उन नियमों को लागू करते हैं जिन्हें मॉडल कभी नहीं तोड़ सकता।
    वे एक कॉन्टेक्स्ट कॉम्पैक्शन को उस तरह पार कर जाते हैं जैसे किसी कॉन्फ़िग फ़ाइल
    का गद्य नहीं कर पाता।
  </Card>
</CardGroup>

## समस्या

एक बड़ा भाषा मॉडल स्टेटलेस है — एक कॉन्टेक्स्ट विंडो, हर कॉल पर मिटा दी जाती है।

* उसके पास आपकी टीम ने जो पहले ही सीखा उसकी **कोई मेमोरी नहीं** है।
* उसके पास किसी एडिट से क्या टूटेगा इसका **कोई पूर्वाभास नहीं** है।
* उसके पास **कोई प्रवर्तित गार्डरेल्स नहीं** हैं — गद्य नियम कॉम्पैक्शन के बाद भुला दिए जाते हैं।

और हर टूल अपनी ही कॉन्फ़िग फ़ाइल चाहता है (`CLAUDE.md`, `AGENTS.md`, `.cursor/rules`,
`GEMINI.md`, MCP…)। Forge वह संज्ञानात्मक सब्सट्रेट है जो तीन गायब चीज़ें उपलब्ध कराता है,
और वह कंपाइलर है जो उसे एक स्रोत से हर टूल तक पहुँचाता है।

## थीसिस

एक मॉडल कॉल्स के बीच आपके कोडबेस से नहीं सीख सकता: उसके वेट फ्रोज़ेन हैं और उसकी
वर्किंग मेमोरी हर प्रतिक्रिया के बाद मिट जाती है। मेमोरी, दूरदर्शिता और आत्म-जाँच
उसमें प्रॉम्प्ट नहीं की जा सकतीं — उन्हें *बाहर* से देना पड़ता है। वही बाहरी परत
संज्ञानात्मक सब्सट्रेट है। औपचारिक रूप से, इनफ़रेंस एक स्थिर फ़ंक्शन `y = f(x)` है जिसमें
कॉल्स के बीच कोई स्टेट नहीं है; Forge वही स्टेट है।

<Steps>
  <Step title="एक बार लिखें">
    अपने नियम और सब्सट्रेट डिफ़ॉल्ट्स एक कैननिकल स्रोत में लिखें
    (`source/rules.json`, `source/substrate.json`, `source/mcp.json`)।
  </Step>

  <Step title="हर जगह कंपाइल करें">
    `forge sync` उस स्रोत को हर टूल की नेटिव कॉन्फ़िग में कंपाइल करता है — नौ AI
    कोडिंग टूल्स और MCP — कंटेंट-हैश हेडर के साथ, ताकि ड्रिफ्ट पहचानी जा सके और
    पुनः चलाना नो-ऑप हो।
  </Step>

  <Step title="हर कार्य पर गेट लगाएँ">
    `forge substrate "<task>"` एक डिटरमिनिस्टिक प्री-एक्शन पास चलाता है: अनुमान,
    रूटिंग, पुनरुपयोग, कॉन्टेक्स्ट, ब्लास्ट रेडियस, स्कोप, और गोल एंकर।
  </Step>

  <Step title="परिणामों से सीखें">
    केवल स्वतंत्र ओरैकल्स — टेस्ट्स, CI, कोई मानव स्वीकृति/रिवर्ट — किसी मेमोरी के
    कॉन्फ़िडेंस को हिला सकते हैं, इसलिए ग़लत सबक जड़ हो जाने के बजाय क्षय होकर मिट जाता है।
  </Step>
</Steps>

## आपको क्या मिलता है

* **सत्रों और टीम-साथियों के बीच बनी रहने वाली मेमोरी।** हर सबक, तथ्य, और सत्यापित
  पुनरुपयोग *प्रूफ-कैरीइंग मेमोरी (PCM)* है — साक्ष्य-संदर्भित, कंटेंट-एड्रेस्ड
  मेमोरी के लिए हमारा नाम: एक दावा जो अपने साक्ष्य के संदर्भ वहन करता है और तब तक
  विश्वसनीय नहीं माना जाता जब तक कि स्वतंत्र ओरैकल्स उसके कॉन्फ़िडेंस को न्यूनतम सीमा से
  ऊपर न उठा दें। "प्रूफ" वही साक्ष्य-मार्ग है, न कि कोई औपचारिक प्रमाण।
* **चीज़ें तोड़ने से पहले दूरदर्शिता।** पूछें "`verifyToken` बदलने से क्या टूटता है?"
  और कोड ग्राफ़ से ब्लास्ट रेडियस पाएँ, जिसमें वे युग्मित फ़ाइलें भी शामिल हैं जिनका
  नाम आपने कभी नहीं लिया।
* **ऐसे गार्डरेल्स जिन्हें भुलाया नहीं जा सकता।** डिटरमिनिस्टिक हुक संरक्षित पथ,
  लागत बजट, और डूम-लूप डिटेक्शन लागू करते हैं — वे कॉन्टेक्स्ट कॉम्पैक्शन को पार कर जाते हैं।
* **ऐसा काम जो अंत तक पूरा हो।** एक कंप्लीशन गेट प्रति सत्र एक बार "done" रोकता है
  जब कोड में परिवर्तन हुआ पर कोई डॉक या स्टेट आर्टिफ़ैक्ट साथ नहीं आया, और मरम्मत
  चेकलिस्ट को उत्तर के रूप में देता है।
* **9 टूल्स के लिए एक कॉन्फ़िग।** अपने नियम एक बार लिखें; Forge हर टूल की नेटिव
  कॉन्फ़िग निकालता है, साथ ही Roo और VS Code के लिए MCP। शून्य रनटाइम निर्भरताएँ —
  एक Node CLI, git में सादी फ़ाइलें, कोई सर्वर नहीं।

## Forge किन टूल्स को फ़ीड करता है?

Forge **नौ टूल्स** के लिए कॉन्फ़िग निकालता है, साथ ही Roo Code और VS Code के लिए
एक MCP सर्वर: Claude Code, Codex, Cursor, Gemini, Aider, Copilot, Windsurf/Devin,
Zed, और Continue। हर एक अपनी ही नेटिव फ़ाइल से वही नियम पढ़ता है।

डिफ़ॉल्ट रूप से केवल एक ही MCP सर्वर वायर होता है — Forge का अपना (`src/cortex_mcp.js`) —
सब्सट्रेट चेक्स और मेमोरी रीड्स के लिए। `context7` जैसे थर्ड-पार्टी MCP सर्वर **ऑप्ट-इन**
हैं और तब तक डिस्क पर नहीं उतरते जब तक आप [`forge integrations add <name> --yes`](/hi/cli/config#forge-integrations)
न चलाएँ।

## ईमानदार सीमाएँ

Forge हर जगह अपनी सीमा स्वयं बताता है।

<Warning>
  Forge नियम-ड्रिफ्ट को **कम करता है, समाप्त नहीं करता।** यह एक पारदर्शिता और
  विश्वसनीयता परत है, टेस्ट्स, समीक्षा, या निर्णय का विकल्प नहीं।
</Warning>

* **गार्ड्स केवल वही लागू करते हैं जो हुक के रूप में व्यक्त किया जा सके** (पथ, फ़ॉर्मैट,
  डिफ़-साइज़, बजट)। अर्थपूर्ण नियम ("फ़ंक्शनल पसंद करें") गद्य रहते हैं और कभी-कभी
  अनदेखे रह जाएँगे।
* **सत्यापन कम करता है, प्रमाणित नहीं करता।** क्रू वेरिफ़ायर और हैलुसिनेटेड-सिंबल
  फ़्लैग समीक्षा भार कम करते हैं; वे कोड को सही सिद्ध नहीं करते।
* **कोई वेट-स्तरीय अधिगम नहीं।** `recall` / `cortex` केवल फ़ाइल-और-प्रॉम्प्ट मेमोरी है — न
  RL, न फ़ाइन-ट्यूनिंग।
* **इम्पैक्ट ग्राफ़ regex-अनुमानित है** — रूढ़िवादी, कोई साउंड कॉल ग्राफ़ नहीं।
* **टेस्ट्स और मानव सुधार हमेशा जीतते हैं।**

<Note>
  Forge **बीटा** में है। कोर (`init`, `sync`, `substrate`, `impact`, `ledger`, guards)
  परखा हुआ है और दैनिक उपयोग में है; कुछ फ़्लैग `1.0` से पहले बदल सकते हैं।
</Note>

## अगले कदम

<CardGroup cols={2}>
  <Card title="क्विकस्टार्ट" icon="rocket" href="/hi/quickstart">
    इंस्टॉल करें, `forge init` चलाएँ, और अपना पहला कार्य सब्सट्रेट के माध्यम से पास कराएँ।
  </Card>

  <Card title="मूल अवधारणाएँ" icon="diagram-project" href="/hi/concepts/config-compiler">
    चार-परत कंपाइलर, प्रूफ-कैरीइंग मेमोरी, और प्री-एक्शन गेट।
  </Card>

  <Card title="CLI संदर्भ" icon="terminal" href="/hi/cli/overview">
    हर कमांड, Core, Memory, Substrate, Quality, और Config के अनुसार समूहित।
  </Card>

  <Card title="टीम मेमोरी" icon="users" href="/hi/guides/team-memory">
    एक टीम-साथी के लेजर को सादे git के ऊपर, संघर्ष-रहित तरीके से मिलाएँ।
  </Card>
</CardGroup>