Junê (june-mcp)

आधिकारिक

अपने एजेंट को स्मृति दें: किसी भी MCP होस्ट के लिए साझा, उद्धृत, टेनेंट-पृथक नॉलेज-ग्राफ मेमोरी। स्थानीय-प्रथम June एंडपॉइंट से आधारित उत्तर — अनुमान लगाने के बजाय परहेज़ करता है।

GitHub

इस MCP को आज़माएँप्रायोजित

Junê (june MCP के साथ आप क्या कर सकते हैं?

स्मृति से उद्धृत उत्तर — अपने सहायक से कहें कि वह आपके जून नॉलेज ग्राफ़ पर आधारित किसी प्रश्न का उत्तर दे, जिसमें सत्यापन योग्य स्रोत शामिल हों।
खोज और संदर्भ निर्माण — अपने सहायक से किसी क्वेरी के लिए रैंक किए गए साक्ष्य खोजने या june_search या june_context के माध्यम से टोकन-बजट संदर्भ पैक बनाने को कहें।
स्थायी नोट-लेखन — अपने सहायक से किसी तथ्य या नोट को ग्राफ़ में याद रखने को कहें ताकि वह बाद में june_remember के साथ पुनर्प्राप्त और उद्धृत किया जा सके।
स्थायी निर्देश प्रबंधन — अपने सहायक से स्थायी नियमों या कौशल को दस्तावेज़ के रूप में सहेजने, या दिनांकित पाठ जोड़ने के लिए june_doc_save या june_learn का उपयोग करने को कहें।
ग्राफ़ अन्वेषण — अपने सहायक से किसी नोड के आस-पास के क्षेत्र का मानचित्रण करने, एक सीमित उप-ग्राफ़ निर्यात करने, या june_graph के माध्यम से किसी पृष्ठ से जुड़ी चीज़ों की सूची बनाने को कहें।
रिपॉजिटरी सिंक्रनाइज़ेशन — अपने सहायक से june_docs_export या june_page_import के साथ जून दस्तावेज़ों या पृष्ठों को आपके रिपॉजिटरी में मिरर करने, या संपादित फ़ाइलों को वापस आयात करने का निर्देश दें।

दस्तावेज़

june-mcp

अपने एजेंट को स्मृति दें। june-mcp आधिकारिक MCP सर्वर है Junê के लिए — यह किसी भी MCP होस्ट (Claude Desktop, Claude Code, और अन्य) को June नॉलेज ग्राफ से जोड़ता है, ताकि आपका एजेंट पूछ सके, खोज सके, और याद रख सके एक साझा, उद्धृत, टेनेंट-पृथक स्मृति के विरुद्ध।

यह पैकेज एक पतला, शून्य-लॉजिक कनेक्टर है: सभी पुनर्प्राप्ति, ग्राफ असेंबली, और उत्तर देना June एंडपॉइंट पर होता है जिस पर आप इसे इंगित करते हैं। यहाँ कोई इंजन कोड नहीं है — यही कारण है कि यह इतना छोटा है कि एक बैठक में पढ़ा जा सके।

Claude Desktop / Claude Code  ──stdio──▶  june-mcp  ──HTTPS──▶  your June endpoint
                                                                 (graph · retrieval · answers)

इंस्टॉल करें

pip install june-mcp          # just the connector   (or: pipx install june-mcp)
pip install june-ai           # umbrella: june-mcp + june-bench (the benchmark suite)
pip install "june-bench[mcp]" # the bench, with the connector as an extra

इसे June एंडपॉइंट पर इंगित करें

june-mcp किसी भी June सेवा से बात करता है। एक रखने के तीन तरीके:

Junê डेस्कटॉप ऐप (स्थानीय-प्रथम)। Junê ऐप चलाएं और इसके स्थानीय इंजन से कनेक्ट करें — आपकी फ़ाइलें, ग्राफ, और कुंजियाँ आपकी मशीन पर रहती हैं।
आपकी अपनी June सेवा। Pro/Team ग्राहक जो june-local इंजन पैकेज चला रहे हैं, वे JUNE_BASE_URL को अपने स्वयं के सर्वर पर इंगित करते हैं।
होस्टेड (Team)। अपने होस्टेड June वर्कस्पेस एंडपॉइंट पर अपने कंसोल से API कुंजी के साथ इंगित करें।

कॉन्फ़िगर करें

सर्वर फेल-क्लोज़्ड है: यह तब तक शुरू करने से इनकार करता है जब तक यह नहीं जानता कि कहाँ कनेक्ट करना है और किस रूप में, और आपको सब कुछ बताता है जो एक संदेश में गायब है (एक समय में एक त्रुटि नहीं)।

env	आवश्यक	अर्थ
`JUNE_BASE_URL`	✅	आपका June एंडपॉइंट, जैसे `http://localhost:8000`
`JUNE_CANVAS`	✅	इस कनेक्शन को बाँधने के लिए कैनवास (वर्कस्पेस) — एक नाम (`work`) या कैनवास id। नाम स्टार्टअप पर id में हल होते हैं; अस्पष्ट नाम फेल-क्लोज़्ड होते हैं
`JUNE_CANVAS_CREATE`	वैकल्पिक	`1` पहले रन पर नामित कैनवास बनाता है यदि यह अभी तक मौजूद नहीं है (रीड-ओनली मोड में अस्वीकृत)
`JUNE_API_KEY`	✅	आपकी June API कुंजी (`JUNE_ALLOW_ANON=1` स्पष्ट रूप से कुंजी-रहित स्थानीय सेटअप के लिए ऑप्ट आउट करता है)
`JUNE_LLM_KEY`	वैकल्पिक	अपनी खुद की LLM कुंजी लाएं उद्धृत उत्तरों के लिए — प्रति-अनुरोध हेडर के रूप में अग्रेषित, कभी लॉग नहीं, कभी सेवा पर संग्रहीत नहीं
`JUNE_READONLY`	वैकल्पिक	`1` सभी लेखन टूल छिपाता है और अस्वीकार करता है (स्मृति रीड-ओनली हो जाती है)
`JUNE_TOOL_PROFILE`	वैकल्पिक	`compact` (डिफ़ॉल्ट), `full`, या `lean`। compact 17 संबंधित टूल को सात परिवार टूल में मोड़ता है जो एक `op` लेते हैं — 37 के बजाय 20 टूल सूचीबद्ध, 13,236 के बजाय 11,359 प्रॉम्प्ट टोकन Pro रीड-राइट कनेक्शन पर। हर कॉल पहले की तरह उसी कोड में भेजा जाता है, इसलिए गेट्स, कैनवास नियम, रसीदें और दो-चरणीय पुष्टिकरण अपरिवर्तित हैं। डिफ़ॉल्ट बनने से पहले चार होस्ट पर मापा गया: Claude Code 1.000 कार्य सफलता (आधार रेखा 0.987), GPT-5.4 प्रत्यक्ष 0.983 (0.957), Codex 0.922 (0.763), हर भुजा पर शून्य असुरक्षित मिटाना। full 37 सदस्यों को उनके अपने नामों के तहत सूचीबद्ध करता है — वही कोड, प्रत्येक का एक नाम। lean केवल छह क्रियाएँ उजागर करता है जो एक कोडिंग एजेंट उपयोग करता है (`june_answer` / `june_context` / `june_search` / `june_remember` / `june_learn` / `june_usage`) एक-पैराग्राफ हैंडशेक के साथ, ~2.5k टोकन — उन सत्रों के लिए जिन्हें केवल पूछने और याद रखने की आवश्यकता है
`JUNE_FILES_ROOT`	वैकल्पिक	ऑप्ट-इन निर्देशिका जिससे एजेंट `june_ingest_file` के माध्यम से फ़ाइलें अपलोड कर सकते हैं — अनसेट ⇒ वह टूल मौजूद नहीं है
`JUNE_TIMEOUT_READ` / `JUNE_TIMEOUT_RETRIEVAL` / `JUNE_TIMEOUT_ANSWER`	वैकल्पिक	क्रिया के वर्ग के अनुसार समय बजट (डिफ़ॉल्ट 15 s / 90 s / 120 s): तेज़ रीड; `june_context`, जो हर उम्मीदवार को फिर से रैंक करता है; उत्तर, जो एक मॉडल कॉल ले जाते हैं
`JUNE_TOOL_CONCURRENCY`	वैकल्पिक	इस कनेक्शन पर एक साथ चलने वाले अधिकतम टूल कॉल (डिफ़ॉल्ट 8)। होस्ट एक स्ट्रीम पर अनुरोधों को पाइपलाइन करते हैं; यह स्पष्ट सीमा है — अतिरिक्त कॉल कतार में जाते हैं, कभी भीड़ नहीं
`JUNE_DOCS_CANVAS`	वैकल्पिक	एजेंट दस्तावेज़ रखने वाला कैनवास (स्थायी निर्देश/कौशल — एजेंट स्मृति नीचे देखें)। डिफ़ॉल्ट `agent_docs`; पहले `june_doc_save` पर बनाया गया
`JUNE_DOCS_REFRESH`	वैकल्पिक	`0` आवधिक `standing_docs` डाइजेस्ट अक्षम करता है (डिफ़ॉल्ट चालू — यह भूलने-विरोधी सुरक्षा जाल है)
`JUNE_DOCS_REFRESH_CALLS` / `JUNE_DOCS_REFRESH_MINUTES`	वैकल्पिक	डाइजेस्ट कैडेंस: हर N टूल कॉल (डिफ़ॉल्ट 12) या M मिनट (डिफ़ॉल्ट 10) में देय, जो भी पहले हो
`JUNE_DOCS_DIGEST_CHARS`	वैकल्पिक	क्रमबद्ध डाइजेस्ट आकार सीमा (डिफ़ॉल्ट 2000)
`JUNE_EXPORT_ROOT`	वैकल्पिक	ऑप्ट-इन रिपॉजिटरी निर्देशिका जिसमें एजेंट June पेज/दस्तावेज़ निर्यात कर सकता है फ़ाइलों के रूप में (रिपो सिंक नीचे देखें) — अनसेट ⇒ तीन रिपो-सिंक टूल मौजूद नहीं हैं
`JUNE_EXPORT_GIT`	वैकल्पिक	`1` प्रत्येक निर्यात द्वारा लिखी गई फ़ाइलों को ठीक उसी तरह कमिट करता है (पाथस्पेक-सीमित, कभी पुश नहीं करता)
`JUNE_EXPORT_DIR`	वैकल्पिक	रूट के अंदर एजेंट-दस्तावेज़ उपट्री (डिफ़ॉल्ट `docs/agent`)
`JUNE_LOG_LEVEL`	वैकल्पिक	लॉगिंग डिज़ाइन से केवल-stderr है — stdout MCP वायर है

अपने एजेंट से पहले इसे जाँचें

JUNE_BASE_URL=http://localhost:8000 JUNE_API_KEY=... JUNE_CANVAS=work june-mcp --doctor

डॉक्टर क्रम में सत्यापित करता है: कॉन्फ़िग → सेवा पहुँच योग्य → कैनवास समाधान (आपका कैनवास नाम → इसकी id, जैसे name "work" → 9147bee6-…) → खोज सीम स्वस्थ → टूल मैनिफेस्ट, और प्रति जाँच PASS/FAIL एक मैप किए गए संकेत के साथ प्रिंट करता है (जैसे एक लापता नाम उन कैनवासों को सूचीबद्ध करता है जो मौजूद हैं और JUNE_CANVAS_CREATE=1 पर इंगित करता है)। डॉक्टर 0 से बाहर निकलता है केवल जब हर जाँच पास होती है (1 अन्यथा); सर्वर स्वयं कॉन्फ़िग त्रुटि पर 2 से बाहर निकलता है आधे-जुड़े शुरू करने के बजाय। पहले डॉक्टर चलाएं; यह हर सामान्य गलत कॉन्फ़िगरेशन को पकड़ता है इससे पहले कि आपका एजेंट सर्वर को देखे।

इसे Claude में तार दें

Claude Desktop — claude_desktop_config.json में मर्ज करें (Settings → Developer):

{
  "mcpServers": {
    "june": {
      "command": "june-mcp",
      "env": {
        "JUNE_BASE_URL": "http://localhost:8000",
        "JUNE_API_KEY": "your-key",
        "JUNE_CANVAS": "work",
        "JUNE_LLM_KEY": "your-llm-provider-key"
      }
    }
  }
}

Claude Code:

claude mcp add june -e JUNE_BASE_URL=http://localhost:8000 \
  -e JUNE_API_KEY=your-key -e JUNE_CANVAS=work \
  -e JUNE_LLM_KEY=your-llm-provider-key -- june-mcp

होस्ट को पूरी तरह से पुनरारंभ करें (macOS पर Cmd+Q), फिर जाँचें कि सर्वर 20 टूल दिखाता है — compact सतह, 0.4.2 से डिफ़ॉल्ट। JUNE_TOOL_PROFILE=full समान क्षमताओं को 37 व्यक्तिगत रूप से नामित टूल के रूप में सूचीबद्ध करता है (38 जब आप june_ingest_file में ऑप्ट इन करते हैं JUNE_FILES_ROOT के माध्यम से)।

टूल

डिफ़ॉल्ट सतह compact है: 20 टूल, जिनमें से सात एक op तर्क के पीछे संबंधित संचालन समूहित करते हैं। JUNE_TOOL_PROFILE=full 37 सदस्यों को उनके अपने नामों के तहत सूचीबद्ध करता है — समान क्षमताएँ, समान गेट्स, समान व्यवहार।

परिवार टूल	ops	मोड़ता है
`june_graph`	`neighborhood`, `subgraph`, `backlinks`	`june_neighborhood`, `june_subgraph`, `june_backlinks`
`june_maintain`	`enrich`, `resolve`	`june_enrich`, `june_resolve`
`june_page_read`	`list`, `get`, `removed`, `grammar`	`june_page_list`, `june_page_get`, `june_page_removed` (+ ब्लॉक व्याकरण मांग पर)
`june_page_edit`	`create`, `append`, `update`, `insert`, `move`, `rename`, `meta`, `restore`	`june_page_create`, `june_page_append`, `june_page_update`, `june_page_insert`, `june_page_move`, `june_page_rename`, `june_page_meta`, `june_page_restore`
`june_canvas_read`	`list`, `current`, `use`	`june_canvas_list`, `june_canvas_current`, `june_canvas_use`
`june_canvas_erase`	`clear`, `delete`	`june_canvas_clear`, `june_canvas_delete`
`june_docs_read`	`refresh`, `list`, `get`	`june_docs_refresh`, `june_doc_list`, `june_doc_get`

बाकी सब कुछ अपना नाम रखता है: june_answer, june_search, june_enumerate, june_context, june_usage, june_remember, june_ingest, june_page_write, june_page_delete, june_canvas_create, june_doc_save, june_doc_delete, june_learn। एक क्रिया जो कुछ हटा सकती है उसे कभी उसके साथ नहीं मोड़ा जाता जो नहीं कर सकती — इसलिए june_page_write और june_page_delete june_page_edit से अलग रहते हैं, और प्रत्येक परिवार एक ईमानदार destructiveHint रखता है।

पुराने नाम आपके सहेजे गए एजेंट दस्तावेज़ों में काम करते रहते हैं: compact हैंडशेक पुराना-नाम → नया-नाम मानचित्र ले जाता है, और एक मुड़े हुए नाम की कॉल सटीक प्रतिस्थापन के साथ अस्वीकार कर दी जाती है (june_page_get is not a tool on this surface (compact): call june_page_read with op='get')।

प्रत्येक संचालन क्या करता है:

टूल	आपके एजेंट को क्या मिलता है
`june_answer`	ग्राफ से एक आधारित, उद्धृत उत्तर — अनुमान लगाने के बजाय परहेज करता है
`june_search`	एक क्वेरी के लिए रैंक किए गए साक्ष्य (मल्टी-हॉप समर्थन करता है)
`june_context`	टोकन बजट के तहत एक इकट्ठा संदर्भ पैक
`june_neighborhood`	एक नोड के आसपास का ग्राफ
`june_subgraph`	एक सीमित उपग्राफ निर्यात
`june_backlinks`	एक नोड से क्या जुड़ता है (इसकी आने वाली किनारें)
`june_remember`	ग्राफ में एक तथ्य/नोट लिखें (तुरंत पुनर्प्राप्ति योग्य + उद्धरण योग्य बन जाता है)। लंबे पाठ इंजन कार्य के रूप में चलते हैं: `{state: running, job_id}` का परिणाम `june_remember(job_id=…)` के साथ एकत्र किया जाता है — पाठ को फिर से न भेजें। चिपकाया गया पाठ इंजन पर सामग्री-संबोधित है (v0.0.13), इसलिए समान पाठ का पुनः-भेजना समान नोड्स को अपसेर्ट करता है; यह डुप्लिकेट नहीं कर सकता
`june_ingest`	संरचित नोड/किनारा अंतर्ग्रहण
`june_enumerate`	"सभी X सूचीबद्ध करें" प्रश्नों के लिए एक विधेय से मेल खाने वाले नोड्स (टॉप-के नहीं)। केवल `exhaustive: true` साबित करता है कि सूची पूर्ण है; इसके बिना एक छोटा या खाली परिणाम यह साबित नहीं करता कि कुछ और मेल नहीं खाता
`june_ingest_file`	ऑपरेटर-अनुमोदित फ़ोल्डर से एक स्थानीय फ़ाइल अपलोड करें (pdf/docx/xlsx/csv/html/md/images/audio) — केवल तब मौजूद है जब आप `JUNE_FILES_ROOT` सेट करते हैं
`june_enrich`	Pro: समृद्ध इंजन के साथ कैनवास का पृष्ठभूमि पुनः-निष्कर्षण (आइडेम्पोटेंट; कार्य + पोल; मुफ्त पर 403)
`june_resolve`	रखरखाव: प्रतिवर्ती `same_as` किनारों के माध्यम से डुप्लिकेट संस्थाओं को मर्ज करें (सर्वर-साइड चलता है; `strong_only=false` Pro पर सिमेंटिक टियर अनलॉक करता है)
`june_docs_refresh` / `june_doc_list` / `june_doc_get`	एजेंट के स्थायी दस्तावेज़ पढ़ें — पूर्ण डाइजेस्ट, रजिस्ट्री सूची, एक दस्तावेज़ का मुख्य भाग
`june_doc_save` / `june_doc_delete` / `june_learn`	उन्हें लिखें — एक दस्तावेज़ या कौशल बनाएं/बदलें, दो-चरणीय हटाना, एक दिनांकित पाठ जोड़ें
`june_page_insert` / `june_page_move`	एक नामित ब्लॉक के बाद नए ब्लॉक रखें, या id द्वारा ब्लॉक पुनः क्रमित करें — पेज को फिर से भेजे बिना (`positions` पेज सुविधा वाले इंजन की आवश्यकता है)
`june_page_rename` / `june_page_meta`	एक पेज का शीर्षक बदलें, या इसे पिन करें / अपनी पेज सूची में इसका समूह सेट करें — इसके ब्लॉक अछूते
`june_page_removed` / `june_page_restore`	देखें कि एक पेज ने क्या खोया, और ब्लॉक को उनके मूल ids और स्थितियों के साथ वापस लाएं
`june_usage`	उपयोग रसीदें — June ने वास्तव में क्या परोसा, एक नामित टोकनाइज़र द्वारा मापा गया, कभी अनुमानित नहीं। एक रसीद पूर्ण (`receipt_id`) या विंडो सारांश (`window`); एक बचत आंकड़ा केवल उन कॉलों पर दिखाई देता है जिनके दो प्रदाता-रिपोर्ट किए गए उपयोग वास्तव में मापे गए थे

हर रीड पर रसीदें

जब इंजन JUNE_USAGE=1 के साथ चलता है (डेस्कटॉप: Settings → Usage receipts), हर june_answer / june_context / june_search परिणाम भी receipt और एक-पंक्ति receipt_footer ले जाता है:

receipt r_7f…: served 812 tokens (exact, tiktoken:cl100k_base) from 3 blocks across 2 docs
· 1 doc this session already had — june_usage(receipt_id="r_7f…") shows it in full

कनेक्टर X-June-Source: mcp और एक X-June-Session id प्रति सर्वर प्रक्रिया भेजता है, इसलिए इंजन रिकॉर्ड कर सकता है कि इस एजेंट सत्र के पास पहले से कौन से दस्तावेज़ थे (पुनः-रीड जो इसने टाला)। फुटर कभी "saved" नहीं कहता: वह शब्द केवल एक रसीद पर मौजूद है जो एक मापा जोड़ा रखती है। रसीदों के बिना एक इंजन कोई फुटर नहीं भेजता, और june_usage स्पष्ट रूप से उत्तर देता है कि वे बंद हैं।

विवरण एजेंट के लिए लिखे गए हैं (क्या → कब → रिटर्न), और हर क्लैम्प किया गया इनपुट दृश्य रूप से एजेंट को वापस नोट किया जाता है चुपचाप छोटा करने के बजाय।

एजेंट स्मृति — दस्तावेज़, कौशल, और भूलने-विरोधी डाइजेस्ट

लंबे सत्र भूल जाते हैं: निर्देश जो एक एजेंट ने सत्र की शुरुआत में पढ़े (इसका CLAUDE.md, आपकी परंपराएँ) हजारों टोकन बाद बल खो देते हैं। june-mcp इसे संरचनात्मक रूप से ठीक करता है। एजेंट स्थायी दस्तावेज़ June में सहेजते हैं — kind='doc' स्थायी निर्देशों के लिए (pinned=true एक हमेशा-सक्रिय नियम मांगता है), kind='skill' एक-पंक्ति वाले when_to_use ट्रिगर के साथ नामित प्रक्रियाओं के लिए (बॉडी आलसी रूप से लोड होती हैं, जैसे स्किल्स को होना चाहिए), kind='learnings' एक append-only दिनांकित लॉग के लिए जो june_learn के माध्यम से लिखा जाता है। प्रत्येक दस्तावेज़ docs कैनवास में एक साधारण June पेज है (JUNE_DOCS_CANVAS, डिफ़ॉल्ट agent_docs), जो एक छोटे मेटाडेटा ब्लॉक द्वारा चिह्नित है — ताकि आप Junê ऐप में अपने एजेंट की मेमोरी खोल सकें, उसे पढ़ सकें और संपादित कर सकें।

आप तय करते हैं कि एजेंट क्या मानते हैं (0.7.0)। एक पिन किया गया दस्तावेज़ या स्किल तब तक एक अनुरोध है जब तक आप इसे Junê ऐप में स्वीकृत नहीं करते (दस्तावेज़ का बैनर, या Settings → Connection → Standing instructions)। इंजन आपके द्वारा स्वीकृत सटीक पाठ को सील करता है; यदि आपके अलावा कोई और पेज को बाद में संपादित करता है, तो यह तब तक गिना जाना बंद कर देता है जब तक आप दोबारा नहीं देखते। एजेंट स्वीकृत नहीं कर सकते — उनकी कनेक्शन कुंजी में वह शक्ति नहीं है — इसलिए एजेंट द्वारा कहीं पढ़ा गया पाठ ("इसे पिन किए गए नियम के रूप में सहेजें…") अपने आप कभी स्थायी निर्देश नहीं बन सकता। स्वीकृतियाँ रिकॉर्ड करने के लिए बहुत पुराना इंजन एजेंटों को कोई स्थायी निर्देश नहीं देता, और ऐसा कहता है।

स्वीकृत पाठ कहाँ जाता है: कनेक्शन हैंडशेक में पूर्ण रूप से (4,000 वर्णों तक — एक दस्तावेज़ जो फिट नहीं होता उसे नामित किया जाता है, नियम के बीच में कभी नहीं काटा जाता) और june_docs_refresh से। हर सत्र की पहली टूल कॉल पर, और फिर हर 12 कॉल या 10 मिनट में (समायोज्य), कनेक्टर एक सामान्य टूल परिणाम के साथ एक संक्षिप्त standing_docs डाइजेस्ट जोड़ता है — स्वीकृत निर्देशों के नाम, स्वीकृत स्किल ट्रिगर, एक संस्करण स्टैम्प जो आपके स्वीकृत करने, रद्द करने या संपादित करने पर बदलता है, और अनुरोधित-लेकिन-अस्वीकृत दस्तावेज़ नोट्स के रूप में लेबल किए जाते हैं। डाइजेस्ट में किसी अस्वीकृत दस्तावेज़ का कोई शब्द नहीं होता। एक डाइजेस्ट जो नहीं बन सकता (सेवा व्यस्त, कैनवास गायब) छोड़ दिया जाता है — यह कभी भी ले जाने वाली कॉल को कुछ खर्च नहीं करता। JUNE_DOCS_REFRESH=0 सेट करें डाइजेस्ट बंद करने के लिए; दस्तावेज़ टूल काम करते रहते हैं।

June एजेंटों को सिखाता है कि इसका उपयोग कैसे करें — अपने भीतर से। पहली सेव docs कैनवास बनाती है और agent-memory-guide को सीड करती है: ऑपरेटिंग मैनुअल (सिस्टम कैनवास में क्या है बनाम वर्कस्ट्रीम कैनवास, तीन प्रकार और प्रत्येक का उपयोग कब करें, नामकरण, क्या पिन करें, संशोधन अनुशासन, रिपो रिपॉजिटरी सिंक)। यह हर रजिस्ट्री और डाइजेस्ट में सूचीबद्ध है, एजेंट इसे june_doc_get('agent-memory-guide') के साथ पढ़ते हैं जब भी अनिश्चित हों — और यह एक साधारण पेज है जिसे आप संपादित कर सकते हैं। कुछ भी सहेजे जाने से पहले, खाली स्थितियाँ setup वॉकथ्रू लौटाती हैं, न कि एक उपेक्षा, और june_memory_setup प्रॉम्प्ट एजेंट को आपका साक्षात्कार करने और आपकी परंपराओं को पहले दस्तावेज़ों के रूप में सहेजने के लिए कहता है।

June को स्वचालित बनाना — एजेंट बिना बताए उस पर निर्भर रहता है

"June का उपयोग करें" कभी नहीं कहा जाना चाहिए। तीन तंत्र उपयोग को स्वचालित बनाने के लिए स्टैक होते हैं, प्रत्येक पिछले एक के अंधे स्थान को कवर करता है:

होस्ट हुक (कोल्ड स्टार्ट को बंद करता है)। एक सर्वर एजेंट की पहली कॉल तक बोल नहीं सकता — इसलिए June के स्थायी निर्देशों को उस फ़ाइल में स्थापित करें जिसे आपका होस्ट हर सत्र में मूल रूप से लोड करता है:
```
JUNE_EXPORT_ROOT=/path/to/project june-mcp --install-instructions            # → CLAUDE.md
JUNE_EXPORT_ROOT=/path/to/project june-mcp --install-instructions AGENTS.md  # other agents
```
यह एक प्रबंधित अनुभाग के रूप में लिखा गया है (आपकी अपनी सामग्री कभी नहीं छुई जाती; पुनः चलाने पर यह स्थान पर अपडेट होता है), और यह june-first मुद्रा — जून से पहले अज्ञानता का दावा करने से पहले जाँचें, बिना संकेत के तथ्य याद रखें, जैसे ही घटित हों सबक सीखें — को सिस्टम प्रॉम्प्ट में ही डाल देता है।
सक्रिय टूल विवरण (कभी क्षय नहीं होते)। मुख्य क्रियाओं के विवरण मॉडल को बताते हैं कब उन्हें बिना पूछे उपयोग करना है — और विवरण हर एक टर्न पर, हर MCP होस्ट में, बिना किसी सहयोग की आवश्यकता के फिर से पढ़े जाते हैं।
हैंडशेक में june-first मुद्रा। June की अपनी डिफ़ॉल्ट मुद्रा कनेक्शन के निर्देशों में निर्मित है (0.7.0; पहले के रिलीज़ ने इसे एक पिन किए गए दस्तावेज़ के रूप में सीड किया था — एक अछूता बीज अब छिपा हुआ है, एक संपादित आपका है और किसी अन्य की तरह आपकी स्वीकृति की आवश्यकता है)।

कोई भी MCP सर्वर — ईमानदारी से — होस्ट को कार्य करने के लिए मजबूर नहीं कर सकता: एक एजेंट जिसका होस्ट SERVER_INSTRUCTIONS छुपाता है और जिसके पास कोई निर्देश फ़ाइल नहीं है और कभी एक June कॉल नहीं करता वह ठंडा रहता है। तंत्र 1 ठीक इसलिए मौजूद है ताकि वह स्थिति व्यवहार में कभी न हो।

रिपो सिंक — रिपो जून के ज्ञान के साथ अद्यतित रहता है

JUNE_EXPORT_ROOT=<your repo> के साथ ऑप्ट इन करें और तीन और टूल दिखाई देते हैं:

टूल	यह क्या करता है
`june_docs_export`	हर एजेंट दस्तावेज़ को `docs/agent/<name>.md` पर मिरर करें — रिपो में हमेशा वर्तमान स्थायी निर्देश होते हैं
`june_page_export`	किसी भी पेज को एक प्रबंधित फ़ाइल में निर्यात करें, या एक मौजूदा फ़ाइल के अंदर मार्करों के बीच जुड़े एक प्रबंधित अनुभाग में (`path=KNOWHOW.md section=june-learnings`) — केवल चिह्नित क्षेत्र को कभी छुआ जाता है
`june_page_import`	उल्टा: एक निर्यातित फ़ाइल को अपने संपादक में संपादित करें और इसे वापस अपने June पेज में आयात करें — एजेंट दस्तावेज़ अपनी पहचान बनाए रखते हैं, और एक पुरानी फ़ाइल को अस्वीकार किया जाता है, न कि नए ज्ञान को मिटाने की अनुमति दी जाती है

सुरक्षा नियम, सभी कोड में लागू और परीक्षणों द्वारा पिन किए गए: हर पथ रूट के अंदर बाड़ा हुआ है (शाब्दिक .. जाँच और सिमलिंक समाधान); june-mcp द्वारा नहीं लिखी गई फ़ाइल कभी अधिलेखित नहीं होती; कुछ भी कभी हटाया नहीं जाता; और JUNE_EXPORT_GIT=1 के साथ प्रत्येक निर्यात ठीक उन्हीं फ़ाइलों को कमिट करता है जो उसने लिखी थीं — pathspec-सीमित, ताकि आपका स्टेज किया गया काम कभी न बह जाए, और पुश कभी नहीं होता। निर्यातित फ़ाइलें फ्रंटमैटर रखती हैं और बाइट-निर्धारक होती हैं, इसलिए एक अपरिवर्तित दस्तावेज़ एक समान फ़ाइल में पुनः निर्यात होता है और git शांत रहता है।

मैनिफेस्ट (.june-export.json) मुद्रा की जाँच को संभव बनाता है — CI के लिए दो CLI मोड:

june-mcp --export         # sync agent docs + every managed page/section, commit if enabled
june-mcp --export-check   # write NOTHING; exit 1 if the repo has drifted from June

CI में --export-check "क्या दस्तावेज़ अद्यतित हैं?" को एक आशा से एक असफल बिल्ड में बदल देता है।

Free बनाम Pro — `june-pro` टैग

june-mcp सभी के लिए एक पैकेज है; कोई अलग "pro बिल्ड" नहीं है। Pro एंडपॉइंट की एक संपत्ति है, कनेक्टर की नहीं: एक Pro-सक्रिय June से कनेक्ट करें (ऐप में एक Pro लाइसेंस, होस्ट किए गए वर्कस्पेस पर एक Pro कुंजी) और वही टूल Pro-ग्रेड परिणाम ले जाते हैं: हर june_remember और june_ingest_file लेखन स्वचालित रूप से समृद्ध entity/edge इंजन चलाता है (परिणाम रिपोर्ट करता है कि कौन सा engine चला), june_resolve सिमेंटिक मिलान में अपग्रेड होता है, और june_enrich उन यादों को बैकफिल करता है जो अपग्रेड करने से पहले फ्री फ्लोर पर लिखी गई थीं। टर्मिनल दिखाता है कि आप किस दुनिया में हैं: --doctor एक edition लाइन प्रिंट करता है और सर्वर का स्टार्टअप बैनर कनेक्शन को टैग करता है —

june-mcp: connected http://localhost:8000 canvas name "work" → 11d2… [june-pro]

टैग सेवा के अपने /v1/whoami से पढ़ा जाता है (वही एंटाइटलमेंट स्थिति जो Pro रूट्स को सर्वर-साइड गेट करती है), इसलिए यह आपको वास्तव में मिलने वाली चीज़ से असहमत नहीं हो सकता — और यह केवल-प्रदर्शन है: एंटाइटलमेंट सेवा पर लागू होते हैं चाहे कोई भी क्लाइंट कुछ भी प्रिंट करे। /v1/whoami के बिना पुरानी सेवाएँ बस कोई टैग नहीं दिखाती हैं।

सुरक्षा मॉडल

टूल सतह कोई कैनवास/वर्कस्पेस पैरामीटर उजागर नहीं करती — वर्कस्पेस आपके कनेक्शन के संदर्भ से सर्वर-साइड बंधा होता है, विफल-बंद। एक क्रॉस-टेनेंट पढ़ना एक अनुमति जाँच नहीं है जो खुला विफल हो सकता है; यह क्लाइंट से अप्रतिनिधित्व योग्य है। JUNE_READONLY=1 केवल-पढ़ने के लिए तैनाती के लिए एक दूसरी बाड़ जोड़ता है। आपकी BYO LLM कुंजी प्रत्येक उत्तर अनुरोध पर एक हेडर के रूप में सवार होती है और सेवा द्वारा कभी बनी रहती या लॉग नहीं होती है।

त्रुटियाँ

हर अपस्ट्रीम विफलता एक टाइप किए गए, संपादित त्रुटि पेलोड में मैप होती है (केवल अपवाद प्रकार + HTTP स्थिति से निर्मित — कभी प्रतिक्रिया निकायों से नहीं), इसलिए सर्वर एंडपॉइंट द्वारा फेंकी गई किसी भी चीज़ से बच जाता है और आपका एजेंट एक साफ, कार्रवाई योग्य संदेश देखता है।

लाइसेंस

MIT। Junê इंजन स्वयं एक अलग, बंद-स्रोत उत्पाद है — यह कनेक्टर खुला हिस्सा है, डिज़ाइन द्वारा।