FAQ

त्वरित उत्तर और वास्तविक-दुनिया सेटअप (स्थानीय dev, VPS, multi-agent, OAuth/API keys, model failover) के लिए गहन समस्या निवारण। रनटाइम डायग्नोस्टिक्स के लिए Troubleshooting देखें। पूर्ण config संदर्भ के लिए Configuration देखें।

विषय सूची

कुछ टूटा हो तो पहले 60 सेकंड

  1. Quick status (पहली जांच)

    bash
    mayros status

    तेज़ स्थानीय सारांश: OS + update, gateway/service reachability, agents/sessions, provider config + runtime issues (जब gateway reachable हो)।

  2. Pasteable report (share करने के लिए safe)

    bash
    mayros status --all

    Read-only diagnosis log tail के साथ (tokens redacted)।

  3. Daemon + port स्थिति

    bash
    mayros gateway status

    Supervisor runtime vs RPC reachability, probe target URL, और कौन सा config service ने संभवतः उपयोग किया दिखाता है।

  4. Deep probes

    bash
    mayros status --deep

    Gateway health checks + provider probes चलाता है (reachable gateway ज़रूरी)। देखें Health।

  5. Latest log tail करें

    bash
    mayros logs --follow

    अगर RPC down है, तो fallback:

    bash
    tail -f "$(ls -t /tmp/mayros/mayros-*.log | head -1)"

    File logs service logs से अलग हैं; देखें Logging और Troubleshooting।

  6. Doctor चलाएं (repairs)

    bash
    mayros doctor

    Config/state repair/migrate + health checks चलाता है। देखें Doctor।

  7. Gateway snapshot

    bash
    mayros health --json
mayros health --verbose   # errors पर target URL + config path दिखाता है

    Running gateway से full snapshot मांगता है (WS-only)। देखें Health।

त्वरित शुरुआत और पहली बार सेटअप

मैं अटका हुआ हूं - सबसे तेज़ तरीका क्या है?

एक local AI agent उपयोग करें जो आपकी मशीन देख सके। यह Discord में पूछने से कहीं ज़्यादा प्रभावी है, क्योंकि अधिकांश "अटक गया" मामले local config या environment issues हैं जिन्हें remote helpers inspect नहीं कर सकते।

ये tools repo पढ़ सकते हैं, commands चला सकते हैं, logs inspect कर सकते हैं, और आपकी machine-level setup (PATH, services, permissions, auth files) ठीक करने में मदद कर सकते हैं। इन्हें full source checkout दें hackable (git) install से:

bash
curl -fsSL https://maryos.apilium.com/install.sh | bash -s -- --install-method git

यह Mayros git checkout से इंस्टॉल करता है, ताकि agent code + docs पढ़ सके और आप जो exact version चला रहे हैं उसके बारे में reason कर सके। आप बाद में stable पर वापस switch कर सकते हैं --install-method git के बिना installer re-run करके।

टिप: agent से कहें कि plan और supervise करे (step-by-step), फिर सिर्फ ज़रूरी commands execute करे। इससे changes छोटे और audit करने में आसान रहते हैं।

अगर आपको कोई real bug या fix मिलता है, तो कृपया GitHub issue file करें या PR भेजें: https://github.com/ApiliumCode/mayros/issues https://github.com/ApiliumCode/mayros/pulls

इन commands से शुरू करें (मदद मांगते समय outputs share करें):

bash
mayros status
mayros models status
mayros doctor

ये क्या करते हैं:

  • mayros status: gateway/agent health + basic config का quick snapshot।
  • mayros models status: provider auth + model availability चेक करता है।
  • mayros doctor: common config/state issues validate और repair करता है।

अन्य उपयोगी CLI checks: mayros status --all, mayros logs --follow, mayros gateway status, mayros health --verbose।

Quick debug loop: कुछ टूटा हो तो पहले 60 सेकंड। Install docs: Install, Installer flags, Updating।

Mayros इंस्टॉल और सेटअप करने का अनुशंसित तरीका क्या है?

Repo source से चलाने और onboarding wizard उपयोग करने की सिफारिश करता है:

bash
curl -fsSL https://maryos.apilium.com/install.sh | bash
mayros onboard --install-daemon

Wizard UI assets भी अपने आप build कर सकता है। ऑनबोर्डिंग के बाद, आप आमतौर पर Gateway port 18789 पर चलाते हैं।

Source से (contributors/dev):

bash
git clone https://github.com/ApiliumCode/mayros.git
cd mayros
pnpm install
pnpm build
pnpm ui:build # पहली बार चलने पर UI deps अपने आप install करता है
mayros onboard

अगर अभी तक global install नहीं है, तो pnpm mayros onboard से चलाएं।

ऑनबोर्डिंग के बाद डैशबोर्ड कैसे खोलें?

Wizard ऑनबोर्डिंग के तुरंत बाद clean (non-tokenized) dashboard URL के साथ browser खोलता है और summary में link भी print करता है। वह tab खुला रखें; अगर launch नहीं हुआ, तो printed URL उसी machine पर copy/paste करें।

localhost vs remote पर डैशबोर्ड (token) को कैसे authenticate करें?

Localhost (same machine):

  • http://127.0.0.1:18789/ खोलें।
  • अगर auth मांगता है, तो gateway.auth.token (या MAYROS_GATEWAY_TOKEN) से token Control UI settings में paste करें।
  • Gateway host से प्राप्त करें: mayros config get gateway.auth.token (या generate करें: mayros doctor --generate-gateway-token)।

Localhost पर नहीं:

  • Tailscale Serve (अनुशंसित): bind loopback रखें, mayros gateway --tailscale serve चलाएं, https://<magicdns>/ खोलें। अगर gateway.auth.allowTailscale true है, तो identity headers Control UI/WebSocket auth satisfy करते हैं (कोई token नहीं, trusted gateway host मानता है); HTTP APIs को अभी भी token/password चाहिए।
  • Tailnet bind: mayros gateway --bind tailnet --token "<token>" चलाएं, http://<tailscale-ip>:18789/ खोलें, dashboard settings में token paste करें।
  • SSH tunnel: ssh -N -L 18789:127.0.0.1:18789 user@host फिर http://127.0.0.1:18789/ खोलें और Control UI settings में token paste करें।

देखें Dashboard और Web surfaces bind modes और auth details के लिए।

मुझे कौन सा runtime चाहिए?

Node >= 22 ज़रूरी है। pnpm अनुशंसित है। Bun Gateway के लिए अनुशंसित नहीं है।

क्या यह Raspberry Pi पर चलता है?

हां। Gateway lightweight है - docs 512MB-1GB RAM, 1 core, और लगभग 500MB disk personal use के लिए पर्याप्त बताते हैं, और note करते हैं कि Raspberry Pi 4 इसे चला सकता है।

अगर अतिरिक्त headroom चाहिए (logs, media, अन्य services), 2GB अनुशंसित है, लेकिन यह hard minimum नहीं है।

टिप: एक छोटा Pi/VPS Gateway host कर सकता है, और आप local screen/camera/canvas या command execution के लिए अपने laptop/phone पर nodes pair कर सकते हैं। देखें Nodes।

Raspberry Pi इंस्टॉल के लिए कोई टिप्स?

संक्षिप्त: यह काम करता है, लेकिन rough edges की उम्मीद रखें।

  • 64-bit OS उपयोग करें और Node >= 22 रखें।
  • hackable (git) install prefer करें ताकि logs देख सकें और तेज़ update कर सकें।
  • बिना channels/skills के शुरू करें, फिर एक-एक करके जोड़ें।
  • अगर अजीब binary issues आएं, तो यह आमतौर पर ARM compatibility समस्या है।

Docs: Linux, Install।

"wake up my friend" पर अटका है / ऑनबोर्डिंग hatch नहीं हो रही। अब क्या?

वह screen Gateway reachable और authenticated होने पर निर्भर करती है। TUI पहले hatch पर "Wake up, my friend!" अपने आप भेजता है। अगर वह line दिखती है बिना reply के और tokens 0 पर रहते हैं, तो agent कभी चला ही नहीं।

  1. Gateway restart करें:
bash
mayros gateway restart
  1. Status + auth चेक करें:
bash
mayros status
mayros models status
mayros logs --follow
  1. अगर अभी भी hang हो, तो चलाएं:
bash
mayros doctor

अगर Gateway remote है, तो सुनिश्चित करें कि tunnel/Tailscale connection up है और UI सही Gateway पर point कर रहा है। देखें Remote access।

क्या मैं अपना सेटअप नई मशीन (Mac mini) पर migrate कर सकता हूं बिना ऑनबोर्डिंग दोहराए?

हां। state directory और workspace copy करें, फिर एक बार Doctor चलाएं। इससे आपका bot "बिल्कुल वैसा ही" रहता है (memory, session history, auth, और channel state) जब तक आप दोनों locations copy करते हैं:

  1. नई machine पर Mayros इंस्टॉल करें।
  2. पुरानी machine से $MAYROS_STATE_DIR (default: ~/.mayros) copy करें।
  3. अपना workspace copy करें (default: ~/.mayros/workspace)।
  4. mayros doctor चलाएं और Gateway service restart करें।

इससे config, auth profiles, WhatsApp creds, sessions, और memory preserve होती है। अगर remote mode में हैं, तो याद रखें gateway host session store और workspace का मालिक है।

महत्वपूर्ण: अगर आप सिर्फ workspace को GitHub पर commit/push करते हैं, तो आप memory + bootstrap files backup कर रहे हैं, लेकिन session history या auth नहीं। वे ~/.mayros/ के अंदर रहते हैं (उदाहरण ~/.mayros/agents/<agentId>/sessions/)।

संबंधित: Migrating, डिस्क पर चीज़ें कहां हैं, Agent workspace, Doctor, Remote mode।

नवीनतम संस्करण में क्या नया है कहां देखें?

GitHub changelog देखें: https://github.com/ApiliumCode/mayros/blob/main/CHANGELOG.md

नवीनतम entries शीर्ष पर हैं। अगर शीर्ष section Unreleased marked है, तो अगला dated section नवीनतम shipped version है। Entries Highlights, Changes, और Fixes (plus docs/other sections जब ज़रूरी हो) से grouped हैं।

apilium.com/us/doc/maryos एक्सेस नहीं कर पा रहा (SSL error)। अब क्या?

कुछ Comcast/Xfinity connections गलत तरीके से apilium.com/us/doc/maryos को Xfinity Advanced Security से block करते हैं। इसे disable करें या apilium.com/us/doc/maryos allowlist करें, फिर retry करें। अधिक विवरण: Troubleshooting। कृपया इसे unblock करने में मदद करें यहां report करके: https://spa.xfinity.com/check_url_status।

अगर अभी भी site तक नहीं पहुंच पा रहे, तो docs GitHub पर mirrored हैं: https://github.com/ApiliumCode/mayros/tree/main/docs

stable और beta में क्या अंतर है?

Stable और beta npm dist-tags हैं, अलग code lines नहीं:

  • latest = stable
  • beta = testing के लिए early build

हम builds beta पर ship करते हैं, test करते हैं, और जब build solid होता है तो उसी version को latest पर promote करते हैं। इसीलिए beta और stable एक ही version पर point कर सकते हैं।

क्या बदला देखें: https://github.com/ApiliumCode/mayros/blob/main/CHANGELOG.md

beta version कैसे इंस्टॉल करें, और beta और dev में क्या अंतर है?

Beta npm dist-tag beta है (हो सकता है latest से match करे)। Dev main का moving head है (git); जब publish होता है, तो npm dist-tag dev उपयोग करता है।

One-liners (macOS/Linux):

bash
curl -fsSL --proto '=https' --tlsv1.2 https://maryos.apilium.com/install.sh | bash -s -- --beta

bash
curl -fsSL --proto '=https' --tlsv1.2 https://maryos.apilium.com/install.sh | bash -s -- --install-method git

Windows installer (PowerShell): https://maryos.apilium.com/install.ps1

अधिक विवरण: Development channels और Installer flags।

इंस्टॉल और ऑनबोर्डिंग में आमतौर पर कितना समय लगता है?

अनुमानित गाइड:

  • Install: 2-5 मिनट
  • Onboarding: 5-15 मिनट, यह निर्भर करता है कि कितने channels/models configure करते हैं

अगर hang हो, तो Installer अटक गया और मैं अटका हुआ हूं में fast debug loop उपयोग करें।

नवीनतम बिट्स कैसे आज़माएं?

दो विकल्प:

  1. Dev channel (git checkout):
bash
mayros update --channel dev

यह main branch पर switch करता है और source से update करता है।

  1. Hackable install (installer site से):
bash
curl -fsSL https://maryos.apilium.com/install.sh | bash -s -- --install-method git

इससे आपको local repo मिलता है जिसे edit कर सकते हैं, फिर git से update करें।

अगर manual clean clone prefer करते हैं:

bash
git clone https://github.com/ApiliumCode/mayros.git
cd mayros
pnpm install
pnpm build

Docs: Update, Development channels, Install।

इंस्टॉलर अटक गया? अधिक फीडबैक कैसे पाएं?

verbose output के साथ installer re-run करें:

bash
curl -fsSL https://maryos.apilium.com/install.sh | bash -s -- --verbose

verbose के साथ Beta install:

bash
curl -fsSL https://maryos.apilium.com/install.sh | bash -s -- --beta --verbose

hackable (git) install के लिए:

bash
curl -fsSL https://maryos.apilium.com/install.sh | bash -s -- --install-method git --verbose

Windows (PowerShell) equivalent:

powershell
# install.ps1 में अभी dedicated -Verbose flag नहीं है।
Set-PSDebug -Trace 1
& ([scriptblock]::Create((iwr -useb https://maryos.apilium.com/install.ps1))) -NoOnboard
Set-PSDebug -Trace 0

अधिक विकल्प: Installer flags।

Windows install कहता है git not found या mayros not recognized

दो common Windows issues:

1) npm error spawn git / git not found

  • Git for Windows इंस्टॉल करें और सुनिश्चित करें कि git आपके PATH पर है।
  • PowerShell बंद करें और फिर खोलें, फिर installer re-run करें।

2) install के बाद mayros is not recognized

  • आपका npm global bin folder PATH पर नहीं है।

  • Path चेक करें:

    powershell
    npm config get prefix

  • सुनिश्चित करें कि <prefix>\\bin PATH पर है (अधिकांश systems पर यह %AppData%\\npm है)।

  • PATH update करने के बाद PowerShell बंद करें और फिर खोलें।

सबसे आसान Windows setup चाहिए तो native Windows की बजाय WSL2 उपयोग करें। Docs: Windows।

docs में जवाब नहीं मिला - बेहतर जवाब कैसे पाएं?

hackable (git) install उपयोग करें ताकि full source और docs locally हों, फिर अपने bot (या Claude/Codex) से उस folder से पूछें ताकि वह repo पढ़ सके और precisely जवाब दे।

bash
curl -fsSL https://maryos.apilium.com/install.sh | bash -s -- --install-method git

अधिक विवरण: Install और Installer flags।

Linux पर Mayros कैसे इंस्टॉल करें?

संक्षिप्त उत्तर: Linux guide follow करें, फिर onboarding wizard चलाएं।

VPS पर Mayros कैसे इंस्टॉल करें?

कोई भी Linux VPS काम करता है। Server पर install करें, फिर Gateway तक पहुंचने के लिए SSH/Tailscale उपयोग करें।

Guides: exe.dev, Hetzner, Fly.io। Remote access: Gateway remote।

cloud/VPS install guides कहां हैं?

हम common providers के साथ एक hosting hub रखते हैं। एक चुनें और guide follow करें:

cloud में यह कैसे काम करता है: Gateway server पर चलता है, और आप Control UI (या Tailscale/SSH) से अपने laptop/phone से access करते हैं। आपकी state + workspace server पर रहती है, इसलिए host को source of truth मानें और backup लें।

आप local screen/camera/canvas access या अपने laptop पर commands चलाने के लिए उस cloud Gateway से nodes (Mac/iOS/Android/headless) pair कर सकते हैं जबकि Gateway cloud में रहे।

Hub: Platforms। Remote access: Gateway remote। Nodes: Nodes, Nodes CLI।

क्या Mayros से खुद को अपडेट करवा सकते हैं?

संक्षिप्त उत्तर: संभव है, अनुशंसित नहीं। Update flow Gateway restart कर सकता है (जो active session drop करता है), clean git checkout चाहिए हो सकता है, और confirmation prompt कर सकता है। सुरक्षित: operator के रूप में shell से updates चलाएं।

CLI उपयोग करें:

bash
mayros update
mayros update status
mayros update --channel stable|beta|dev
mayros update --tag <dist-tag|version>
mayros update --no-restart

अगर agent से automate करना ज़रूरी है:

bash
mayros update --yes --no-restart
mayros gateway restart

Docs: Update, Updating।

ऑनबोर्डिंग विज़ार्ड वास्तव में क्या करता है?

mayros onboard अनुशंसित setup path है। local mode में यह आपको guide करता है:

  • Model/auth setup (Anthropic setup-token Claude subscriptions के लिए अनुशंसित, OpenAI Codex OAuth supported, API keys optional, LM Studio local models supported)
  • Workspace location + bootstrap files
  • Gateway settings (bind/port/auth/tailscale)
  • Providers (WhatsApp, Telegram, Discord, Mattermost (plugin), Signal, iMessage)
  • Daemon install (macOS पर LaunchAgent; Linux/WSL2 पर systemd user unit)
  • Health checks और skills selection

अगर configured model unknown है या auth missing है तो यह warn भी करता है।

क्या इसे चलाने के लिए Claude या OpenAI subscription चाहिए?

नहीं। आप Mayros API keys (Anthropic/OpenAI/others) या local-only models से चला सकते हैं ताकि data आपके device पर रहे। Subscriptions (Claude Pro/Max या OpenAI Codex) उन providers को authenticate करने के optional तरीके हैं।

Docs: Anthropic, OpenAI, Local models, Models।

क्या Claude Max subscription बिना API key के उपयोग कर सकता हूं?

हां। API key की बजाय setup-token से authenticate कर सकते हैं। यह subscription path है।

Claude Pro/Max subscriptions में API key शामिल नहीं है, इसलिए subscription accounts के लिए यह सही approach है। महत्वपूर्ण: आपको Anthropic से verify करना होगा कि यह usage उनकी subscription policy और terms के तहत allowed है। सबसे explicit, supported path चाहिए तो Anthropic API key उपयोग करें।

Anthropic setup-token auth कैसे काम करता है?

claude setup-token Claude Code CLI से token string generate करता है (web console में available नहीं है)। आप इसे किसी भी machine पर चला सकते हैं। Wizard में Anthropic token (paste setup-token) चुनें या mayros models auth paste-token --provider anthropic से paste करें। Token anthropic provider के लिए auth profile के रूप में store होता है और API key की तरह उपयोग होता है (कोई auto-refresh नहीं)। अधिक विवरण: OAuth।

Anthropic setup-token कहां मिलेगा?

यह Anthropic Console में नहीं है। Setup-token Claude Code CLI से किसी भी machine पर generate होता है:

bash
claude setup-token

जो token print होता है उसे copy करें, फिर wizard में Anthropic token (paste setup-token) चुनें। अगर gateway host पर चलाना है, तो mayros models auth setup-token --provider anthropic उपयोग करें। अगर claude setup-token कहीं और चलाया, तो gateway host पर mayros models auth paste-token --provider anthropic से paste करें। देखें Anthropic।

क्या Claude subscription auth (Claude Pro या Max) सपोर्ट है?

हां - setup-token से। Mayros अब Claude Code CLI OAuth tokens reuse नहीं करता; setup-token या Anthropic API key उपयोग करें। Token कहीं भी generate करें और gateway host पर paste करें। देखें Anthropic और OAuth।

Note: Claude subscription access Anthropic की terms से governed है। Production या multi-user workloads के लिए API keys आमतौर पर safer choice हैं।

Anthropic से HTTP 429 rate_limit_error क्यों दिख रहा है?

इसका मतलब है कि current window के लिए आपकी Anthropic quota/rate limit exhausted है। अगर Claude subscription (setup-token या Claude Code OAuth) उपयोग कर रहे हैं, तो window reset होने तक wait करें या plan upgrade करें। अगर Anthropic API key उपयोग कर रहे हैं, तो usage/billing के लिए Anthropic Console चेक करें और ज़रूरत अनुसार limits बढ़ाएं।

टिप: fallback model set करें ताकि provider rate-limited होने पर Mayros reply करता रहे। देखें Models और OAuth।

क्या AWS Bedrock सपोर्ट है?

हां - pi-ai के Amazon Bedrock (Converse) provider से manual config के साथ। आपको gateway host पर AWS credentials/region provide करने होंगे और models config में Bedrock provider entry जोड़नी होगी। देखें Amazon Bedrock और Model providers। अगर managed key flow prefer करते हैं, तो Bedrock के सामने OpenAI-compatible proxy भी valid option है।

Codex auth कैसे काम करता है?

Mayros OAuth (ChatGPT sign-in) से OpenAI Code (Codex) support करता है। Wizard OAuth flow चला सकता है और उचित होने पर default model openai-codex/gpt-5.3-codex set करता है। देखें Model providers और Wizard।

क्या OpenAI subscription auth (Codex OAuth) सपोर्ट है?

हां। Mayros पूरी तरह OpenAI Code (Codex) subscription OAuth support करता है। Onboarding wizard आपके लिए OAuth flow चला सकता है।

देखें OAuth, Model providers, और Wizard।

Gemini CLI OAuth कैसे सेटअप करें?

Gemini CLI plugin auth flow उपयोग करता है, mayros.json में client id या secret नहीं।

Steps:

  1. Plugin enable करें: mayros plugins enable google-gemini-cli-auth
  2. Login: mayros models auth login --provider google-gemini-cli --set-default

यह gateway host पर auth profiles में OAuth tokens store करता है। विवरण: Model providers।

क्या casual chats के लिए local model ठीक है?

आमतौर पर नहीं। Mayros को large context + strong safety चाहिए; छोटे cards truncate और leak करते हैं। अगर ज़रूरी है, तो locally सबसे बड़ा MiniMax M2.1 build चलाएं जो हो सके (LM Studio) और देखें /gateway/local-models। छोटे/quantized models prompt-injection risk बढ़ाते हैं - देखें Security।

hosted model traffic को specific region में कैसे रखें?

Region-pinned endpoints चुनें। OpenRouter MiniMax, Kimi, और GLM के लिए US-hosted options expose करता है; data in-region रखने के लिए US-hosted variant चुनें। models.mode: "merge" उपयोग करके Anthropic/OpenAI alongside list कर सकते हैं ताकि fallbacks available रहें जबकि regioned provider respect हो।

क्या इसे इंस्टॉल करने के लिए Mac Mini खरीदना ज़रूरी है?

नहीं। Mayros macOS या Linux (Windows WSL2 से) पर चलता है। Mac mini optional है - कुछ लोग always-on host के रूप में खरीदते हैं, लेकिन छोटा VPS, home server, या Raspberry Pi-class box भी काम करता है।

Mac सिर्फ macOS-only tools के लिए चाहिए। iMessage के लिए BlueBubbles (अनुशंसित) उपयोग करें - BlueBubbles server किसी भी Mac पर चलता है, और Gateway Linux या कहीं और चल सकता है। अन्य macOS-only tools चाहिए तो Gateway Mac पर चलाएं या macOS node pair करें।

Docs: BlueBubbles, Nodes, Mac remote mode।

iMessage सपोर्ट के लिए क्या Mac mini चाहिए?

Messages में signed in कोई macOS device चाहिए। Mac mini होना ज़रूरी नहीं - कोई भी Mac काम करता है। iMessage के लिए BlueBubbles (अनुशंसित) उपयोग करें - BlueBubbles server macOS पर चलता है, जबकि Gateway Linux या कहीं और चल सकता है।

Common setups:

  • Gateway Linux/VPS पर चलाएं, और BlueBubbles server Messages में signed in किसी Mac पर चलाएं।
  • सबसे simple single-machine setup चाहिए तो सब कुछ Mac पर चलाएं।

Docs: BlueBubbles, Nodes, Mac remote mode।

अगर Mayros चलाने के लिए Mac mini खरीदूं, तो क्या इसे MacBook Pro से कनेक्ट कर सकता हूं?

हां। Mac mini Gateway चला सकता है, और आपका MacBook Pro node (companion device) के रूप में connect हो सकता है। Nodes Gateway नहीं चलाते - वे उस device पर screen/camera/canvas और system.run जैसी अतिरिक्त capabilities provide करते हैं।

Common pattern:

  • Mac mini पर Gateway (always-on)।
  • MacBook Pro macOS app या node host चलाता है और Gateway से pair होता है।
  • mayros nodes status / mayros nodes list से देखें।

Docs: Nodes, Nodes CLI।

क्या Bun उपयोग कर सकता हूं?

Bun अनुशंसित नहीं है। हम runtime bugs देखते हैं, विशेषकर WhatsApp और Telegram के साथ। Stable gateways के लिए Node उपयोग करें।

अगर फिर भी Bun experiment करना चाहते हैं, तो WhatsApp/Telegram बिना non-production gateway पर करें।

Telegram: allowFrom में क्या जाता है?

channels.telegram.allowFrom human sender का Telegram user ID (numeric) है। Bot username नहीं।

Onboarding wizard @username input accept करता है और numeric ID में resolve करता है, लेकिन Mayros authorization सिर्फ numeric IDs उपयोग करता है।

सुरक्षित (बिना third-party bot):

  • अपने bot को DM करें, फिर mayros logs --follow चलाएं और from.id पढ़ें।

Official Bot API:

  • अपने bot को DM करें, फिर https://api.telegram.org/bot<bot_token>/getUpdates call करें और message.from.id पढ़ें।

Third-party (कम private):

  • @userinfobot या @getidsbot को DM करें।

देखें /channels/telegram।

क्या कई लोग एक WhatsApp नंबर से अलग-अलग Mayros instances उपयोग कर सकते हैं?

हां, multi-agent routing से। प्रत्येक sender के WhatsApp DM (peer kind: "direct", sender E.164 जैसे +15551234567) को अलग agentId से bind करें, ताकि प्रत्येक व्यक्ति को अपना workspace और session store मिले। Replies अभी भी उसी WhatsApp account से आते हैं, और DM access control (channels.whatsapp.dmPolicy / channels.whatsapp.allowFrom) प्रति WhatsApp account global है। देखें Multi-Agent Routing और WhatsApp।

क्या "fast chat" agent और "Opus for coding" agent चला सकता हूं?

हां। Multi-agent routing उपयोग करें: प्रत्येक agent को अपना default model दें, फिर inbound routes (provider account या specific peers) को प्रत्येक agent से bind करें। Example config Multi-Agent Routing में है। यह भी देखें Models और Configuration।

क्या Homebrew Linux पर काम करता है?

हां। Homebrew Linux (Linuxbrew) support करता है। Quick setup:

bash
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
echo 'eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"' >> ~/.profile
eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"
brew install <formula>

अगर systemd से Mayros चलाते हैं, तो सुनिश्चित करें कि service PATH में /home/linuxbrew/.linuxbrew/bin (या आपका brew prefix) शामिल है ताकि brew-installed tools non-login shells में resolve हों। Recent builds Linux systemd services पर common user bin dirs भी prepend करते हैं (उदाहरण ~/.local/bin, ~/.npm-global/bin, ~/.local/share/pnpm, ~/.bun/bin) और PNPM_HOME, NPM_CONFIG_PREFIX, BUN_INSTALL, VOLTA_HOME, ASDF_DATA_DIR, NVM_DIR, और FNM_DIR set होने पर honor करते हैं।

hackable (git) install और npm install में क्या अंतर है?

  • Hackable (git) install: full source checkout, editable, contributors के लिए best। Builds locally चलाते हैं और code/docs patch कर सकते हैं।
  • npm install: global CLI install, कोई repo नहीं, "बस चलाओ" के लिए best। Updates npm dist-tags से आते हैं।

Docs: Getting started, Updating।

क्या बाद में npm और git installs के बीच switch कर सकता हूं?

हां। दूसरा flavor install करें, फिर Doctor चलाएं ताकि gateway service नए entrypoint पर point करे। इससे data delete नहीं होता - सिर्फ Mayros code install बदलता है। आपकी state (~/.mayros) और workspace (~/.mayros/workspace) untouched रहती हैं।

npm → git:

bash
git clone https://github.com/ApiliumCode/mayros.git
cd mayros
pnpm install
pnpm build
mayros doctor
mayros gateway restart

git → npm:

bash
npm install -g mayros@latest
mayros doctor
mayros gateway restart

Doctor gateway service entrypoint mismatch detect करता है और current install से match करने के लिए service config rewrite करने का offer करता है (automation में --repair उपयोग करें)।

Backup tips: देखें Backup strategy।

Gateway लैपटॉप पर चलाऊं या VPS पर?

संक्षिप्त उत्तर: 24/7 reliability चाहिए तो VPS उपयोग करें। सबसे कम friction चाहिए और sleep/restarts ठीक हैं, तो locally चलाएं।

Laptop (local Gateway)

  • Pros: कोई server cost नहीं, local files तक direct access, live browser window।
  • Cons: sleep/network drops = disconnects, OS updates/reboots interrupt, awake रहना ज़रूरी।

VPS / cloud

  • Pros: always-on, stable network, कोई laptop sleep issues नहीं, चालू रखना आसान।
  • Cons: अक्सर headless चलता है (screenshots उपयोग करें), सिर्फ remote file access, updates के लिए SSH करना होगा।

Mayros-specific note: WhatsApp/Telegram/Slack/Mattermost (plugin)/Discord सब VPS से ठीक काम करते हैं। एकमात्र real trade-off headless browser vs visible window है। देखें Browser।

अनुशंसित default: अगर पहले gateway disconnects हुए हों तो VPS। Local तब बढ़िया है जब actively Mac उपयोग कर रहे हों और local file access या visible browser के साथ UI automation चाहिए।

Mayros को dedicated machine पर चलाना कितना ज़रूरी है?

ज़रूरी नहीं, लेकिन reliability और isolation के लिए अनुशंसित।

  • Dedicated host (VPS/Mac mini/Pi): always-on, कम sleep/reboot interruptions, cleaner permissions, चालू रखना आसान।
  • Shared laptop/desktop: testing और active use के लिए बिल्कुल ठीक, लेकिन machine sleep या update होने पर pauses की उम्मीद रखें।

दोनों का best चाहिए तो Gateway dedicated host पर रखें और laptop को local screen/camera/exec tools के लिए node के रूप में pair करें। देखें Nodes। Security guidance के लिए Security पढ़ें।

न्यूनतम VPS requirements और अनुशंसित OS क्या हैं?

Mayros lightweight है। Basic Gateway + एक chat channel के लिए:

  • Absolute minimum: 1 vCPU, 1GB RAM, ~500MB disk।
  • अनुशंसित: headroom के लिए 1-2 vCPU, 2GB RAM या अधिक (logs, media, multiple channels)। Node tools और browser automation resource hungry हो सकते हैं।

OS: Ubuntu LTS (या कोई modern Debian/Ubuntu) उपयोग करें। Linux install path वहां सबसे अच्छा tested है।

Docs: Linux, VPS hosting।

क्या VM में Mayros चला सकता हूं और requirements क्या हैं?

हां। VM को VPS जैसा ही treat करें: always on होना चाहिए, reachable होना चाहिए, और Gateway और enable किए channels के लिए पर्याप्त RAM होनी चाहिए।

Baseline guidance:

  • Absolute minimum: 1 vCPU, 1GB RAM।
  • अनुशंसित: 2GB RAM या अधिक अगर multiple channels, browser automation, या media tools चलाते हैं।
  • OS: Ubuntu LTS या कोई modern Debian/Ubuntu।

Windows पर हैं तो WSL2 सबसे आसान VM style setup है और सबसे अच्छी tooling compatibility है। देखें Windows, VPS hosting। macOS VM में चला रहे हैं तो देखें macOS VM।

Mayros क्या है?

Mayros क्या है, एक पैराग्राफ में?

Mayros एक personal AI assistant है जो आप अपने devices पर चलाते हैं। यह उन messaging surfaces पर reply करता है जो आप पहले से उपयोग करते हैं (WhatsApp, Telegram, Slack, Mattermost (plugin), Discord, Google Chat, Signal, iMessage, WebChat) और supported platforms पर voice + live Canvas भी कर सकता है। Gateway always-on control plane है; assistant product है।

value proposition क्या है?

Mayros "सिर्फ एक Claude wrapper" नहीं है। यह एक local-first control plane है जो आपको अपने hardware पर एक capable assistant चलाने देता है, जो उन chat apps से reachable है जो आप पहले से उपयोग करते हैं, stateful sessions, memory, और tools के साथ - बिना अपने workflows का control किसी hosted SaaS को दिए।

Highlights:

  • आपके devices, आपका data: Gateway जहां चाहें चलाएं (Mac, Linux, VPS) और workspace + session history local रखें।
  • Real channels, web sandbox नहीं: WhatsApp/Telegram/Slack/Discord/Signal/iMessage/etc, plus supported platforms पर mobile voice और Canvas।
  • Model-agnostic: Anthropic, OpenAI, MiniMax, OpenRouter, etc. उपयोग करें, per-agent routing और failover के साथ।
  • Local-only option: local models चलाएं ताकि चाहें तो सारा data आपके device पर रहे।
  • Multi-agent routing: channel, account, या task के अनुसार अलग agents, प्रत्येक अपने workspace और defaults के साथ।
  • Open source और hackable: बिना vendor lock-in के inspect, extend, और self-host करें।

Docs: Gateway, Channels, Multi-agent, Memory।

अभी सेटअप किया - पहले क्या करूं?

अच्छे पहले projects:

  • Website बनाएं (WordPress, Shopify, या simple static site)।
  • Mobile app prototype करें (outline, screens, API plan)।
  • Files और folders organize करें (cleanup, naming, tagging)।
  • Gmail connect करें और summaries या follow ups automate करें।

यह बड़े tasks handle कर सकता है, लेकिन सबसे अच्छा काम करता है जब phases में split करें और parallel work के लिए sub agents उपयोग करें।

Mayros के शीर्ष पांच रोज़मर्रा के use cases क्या हैं?

Everyday wins आमतौर पर ऐसे दिखते हैं:

  • Personal briefings: inbox, calendar, और आपकी care की news के summaries।
  • Research और drafting: quick research, summaries, और emails या docs के first drafts।
  • Reminders और follow ups: cron या heartbeat driven nudges और checklists।
  • Browser automation: forms भरना, data collect करना, और web tasks repeat करना।
  • Cross device coordination: phone से task भेजें, Gateway server पर चलाने दें, और result chat में वापस पाएं।

क्या Mayros SaaS के लिए lead gen outreach ads और blogs में मदद कर सकता है?

Research, qualification, और drafting के लिए हां। यह sites scan, shortlists build, prospects summarize, और outreach या ad copy drafts लिख सकता है।

Outreach या ad runs के लिए human in the loop रखें। Spam से बचें, local laws और platform policies follow करें, और भेजने से पहले सब कुछ review करें। सबसे safe pattern: Mayros draft करे और आप approve करें।

Docs: Security।

web development के लिए Claude Code की तुलना में क्या फायदे हैं?

Mayros एक personal assistant और coordination layer है, IDE replacement नहीं। Repo के अंदर सबसे तेज़ direct coding loop के लिए Claude Code या Codex उपयोग करें। Mayros उपयोग करें जब durable memory, cross-device access, और tool orchestration चाहिए।

फायदे:

  • Sessions में persistent memory + workspace
  • Multi-platform access (WhatsApp, Telegram, TUI, WebChat)
  • Tool orchestration (browser, files, scheduling, hooks)
  • Always-on Gateway (VPS पर चलाएं, कहीं से भी interact करें)
  • Local browser/screen/camera/exec के लिए Nodes

Showcase: https://apilium.com/us/products/maryos/showcase

Skills और automation

repo को dirty रखे बिना skills कैसे customize करें?

Repo copy edit करने की बजाय managed overrides उपयोग करें। अपने changes ~/.mayros/skills/<name>/SKILL.md में रखें (या ~/.mayros/mayros.json में skills.load.extraDirs से folder जोड़ें)। Precedence <workspace>/skills > ~/.mayros/skills > bundled है, इसलिए managed overrides git touch किए बिना जीतती हैं। सिर्फ upstream-worthy edits repo में रहनी चाहिए और PRs के रूप में जानी चाहिए।

क्या custom folder से skills लोड कर सकता हूं?

हां। ~/.mayros/mayros.json में skills.load.extraDirs से extra directories जोड़ें (lowest precedence)। Default precedence रहती है: <workspace>/skills → ~/.mayros/skills → bundled → skills.load.extraDirs। skills-hub default रूप से ./skills में install करता है, जिसे Mayros <workspace>/skills मानता है।

अलग-अलग tasks के लिए अलग-अलग models कैसे उपयोग करें?

आज supported patterns हैं:

  • Cron jobs: isolated jobs प्रति job model override set कर सकते हैं।
  • Sub-agents: अलग default models वाले separate agents को tasks route करें।
  • On-demand switch: किसी भी समय current session model switch करने के लिए /model उपयोग करें।

देखें Cron jobs, Multi-Agent Routing, और Slash commands।

heavy work के दौरान bot freeze हो जाता है। कैसे offload करें?

लंबे या parallel tasks के लिए sub-agents उपयोग करें। Sub-agents अपने session में चलते हैं, summary return करते हैं, और आपकी main chat responsive रखते हैं।

अपने bot से कहें "इस task के लिए sub-agent spawn करो" या /subagents उपयोग करें। Gateway अभी क्या कर रहा है (और busy है या नहीं) देखने के लिए chat में /status उपयोग करें।

Token tip: लंबे tasks और sub-agents दोनों tokens consume करते हैं। Cost concern है तो agents.defaults.subagents.model से sub-agents के लिए cheaper model set करें।

Docs: Sub-agents।

Cron या reminders fire नहीं हो रहे। क्या चेक करें?

Cron Gateway process के अंदर चलता है। अगर Gateway continuously नहीं चल रहा, तो scheduled jobs नहीं चलेंगे।

Checklist:

  • Confirm करें cron enabled है (cron.enabled) और MAYROS_SKIP_CRON set नहीं है।
  • चेक करें Gateway 24/7 चल रहा है (कोई sleep/restarts नहीं)।
  • Job के timezone settings verify करें (--tz vs host timezone)।

Debug:

bash
mayros cron run <jobId> --force
mayros cron runs --id <jobId> --limit 50

Docs: Cron jobs, Cron vs Heartbeat।

Linux पर skills कैसे इंस्टॉल करें?

Skills Hub (CLI) उपयोग करें या workspace में skills drop करें। macOS Skills UI Linux पर available नहीं है। Skills browse करें https://hub.apilium.com पर।

Skills Hub CLI install करें (एक package manager चुनें):

bash
npm i -g @apilium/skills-hub-cli

bash
pnpm add -g @apilium/skills-hub-cli

क्या Mayros schedule पर या background में continuously tasks चला सकता है?

हां। Gateway scheduler उपयोग करें:

  • Cron jobs scheduled या recurring tasks के लिए (restarts में persist)।
  • Heartbeat "main session" periodic checks के लिए।
  • Isolated jobs autonomous agents के लिए जो summaries post या chats में deliver करें।

Docs: Cron jobs, Cron vs Heartbeat, Heartbeat।

क्या Linux से Apple macOS-only skills चला सकता हूं?

Directly नहीं। macOS skills metadata.mayros.os plus required binaries से gated हैं, और skills system prompt में तभी दिखती हैं जब Gateway host पर eligible हों। Linux पर darwin-only skills (जैसे apple-notes, apple-reminders, things-mac) load नहीं होंगी जब तक gating override न करें।

तीन supported patterns हैं:

Option A - Gateway Mac पर चलाएं (सबसे simple)। Gateway वहां चलाएं जहां macOS binaries हैं, फिर remote mode या Tailscale से Linux से connect करें। Skills normally load होती हैं क्योंकि Gateway host macOS है।

Option B - macOS node उपयोग करें (बिना SSH)। Gateway Linux पर चलाएं, macOS node (menubar app) pair करें, और Mac पर Node Run Commands को "Always Ask" या "Always Allow" set करें। Mayros macOS-only skills को eligible treat कर सकता है जब required binaries node पर exist करती हैं। Agent उन skills को nodes tool से चलाता है। "Always Ask" चुनने पर prompt में "Always Allow" approve करने से वह command allowlist में add होता है।

Option C - SSH से macOS binaries proxy करें (advanced)। Gateway Linux पर रखें, लेकिन required CLI binaries SSH wrappers में resolve करवाएं जो Mac पर चलें। फिर skill override करें ताकि Linux allow हो और eligible रहे।

  1. Binary के लिए SSH wrapper बनाएं (उदाहरण: Apple Notes के लिए memo):

    bash
    #!/usr/bin/env bash
set -euo pipefail
exec ssh -T user@mac-host /opt/homebrew/bin/memo "$@"

  2. Wrapper Linux host पर PATH पर रखें (उदाहरण ~/bin/memo)।

  3. Skill metadata override करें (workspace या ~/.mayros/skills) ताकि Linux allow हो:

    markdown
    ---
name: apple-notes
description: Manage Apple Notes via the memo CLI on macOS.
metadata: { "mayros": { "os": ["darwin", "linux"], "requires": { "bins": ["memo"] } } }
---

  4. Skills snapshot refresh के लिए नया session शुरू करें।

क्या Notion या HeyGen integration है?

आज built-in नहीं।

Options:

  • Custom skill / plugin: reliable API access के लिए best (Notion/HeyGen दोनों के APIs हैं)।
  • Browser automation: बिना code के काम करता है लेकिन slower और ज़्यादा fragile है।

Per client context रखना चाहते हैं (agency workflows) तो simple pattern:

  • प्रति client एक Notion page (context + preferences + active work)।
  • Session शुरू होने पर agent से वह page fetch करवाएं।

Native integration चाहिए तो feature request खोलें या उन APIs targeting skill बनाएं।

Skills install करें:

bash
mayros skills hub install <skill-slug>
mayros skills hub update --all

Skills Hub आपकी current directory के ./skills में install करता है (या configured Mayros workspace में fallback); Mayros अगले session पर उसे <workspace>/skills treat करता है। Agents में shared skills के लिए ~/.mayros/skills/<name>/SKILL.md में रखें। कुछ skills Homebrew से installed binaries expect करती हैं; Linux पर इसका मतलब Linuxbrew है (ऊपर Homebrew Linux FAQ entry देखें)। देखें Skills और Skills Hub।

browser takeover के लिए Chrome extension कैसे इंस्टॉल करें?

Built-in installer उपयोग करें, फिर Chrome में unpacked extension load करें:

bash
mayros browser extension install
mayros browser extension path

फिर Chrome → chrome://extensions → "Developer mode" enable करें → "Load unpacked" → वह folder चुनें।

Full guide (remote Gateway + security notes सहित): Chrome extension

अगर Gateway Chrome जैसी machine पर चलता है (default setup), तो आमतौर पर कुछ extra चाहिए नहीं। अगर Gateway कहीं और चलता है, तो browser machine पर node host चलाएं ताकि Gateway browser actions proxy कर सके। आपको अभी भी जिस tab को control करना चाहते हैं उस पर extension button click करना होगा (auto-attach नहीं होता)।

Sandboxing और memory

क्या dedicated sandboxing doc है?

हां। देखें Sandboxing। Docker-specific setup (Docker में full gateway या sandbox images) के लिए देखें Docker।

Docker limited लगता है। Full features कैसे enable करें?

Default image security-first है और node user के रूप में चलती है, इसलिए इसमें system packages, Homebrew, या bundled browsers शामिल नहीं हैं। Fuller setup के लिए:

  • /home/node को MAYROS_HOME_VOLUME से persist करें ताकि caches survive करें।
  • MAYROS_DOCKER_APT_PACKAGES से system deps image में bake करें।
  • Bundled CLI से Playwright browsers install करें: node /app/node_modules/playwright-core/cli.js install chromium
  • PLAYWRIGHT_BROWSERS_PATH set करें और path persisted होना सुनिश्चित करें।

Docs: Docker, Browser।

क्या DMs personal रखते हुए groups public sandboxed एक agent से कर सकता हूं?

हां - अगर private traffic DMs है और public traffic groups है।

agents.defaults.sandbox.mode: "non-main" उपयोग करें ताकि group/channel sessions (non-main keys) Docker में चलें, जबकि main DM session on-host रहे। फिर tools.sandbox.tools से sandboxed sessions में available tools restrict करें।

Setup walkthrough + example config: Groups: personal DMs + public groups

Key config reference: Gateway configuration

sandbox में host folder कैसे bind करें?

agents.defaults.sandbox.docker.binds को ["host:path:mode"] set करें (उदा. "/home/user/src:/src:ro")। Global + per-agent binds merge होते हैं; scope: "shared" होने पर per-agent binds ignore होते हैं। Sensitive चीज़ों के लिए :ro उपयोग करें और याद रखें binds sandbox filesystem walls bypass करते हैं। Examples और safety notes के लिए देखें Sandboxing और Sandbox vs Tool Policy vs Elevated।

memory कैसे काम करती है?

Mayros memory बस agent workspace में Markdown files हैं:

  • Daily notes memory/YYYY-MM-DD.md में
  • Curated long-term notes MEMORY.md में (सिर्फ main/private sessions)

Mayros auto-compaction से पहले model को durable notes लिखने की याद दिलाने के लिए silent pre-compaction memory flush भी चलाता है। यह तभी चलता है जब workspace writable हो (read-only sandboxes skip करते हैं)। देखें Memory।

Memory चीज़ें भूलती रहती है। कैसे स्थायी बनाएं?

Bot से कहें fact memory में लिखो। Long-term notes MEMORY.md में belong करती हैं, short-term context memory/YYYY-MM-DD.md में जाता है।

यह अभी भी एक area है जिसे हम improve कर रहे हैं। Model को memories store करने की याद दिलाने से मदद मिलती है; इसे पता होगा क्या करना है। अगर भूलता रहता है, तो verify करें कि Gateway हर run पर same workspace उपयोग कर रहा है।

Docs: Memory, Agent workspace।

क्या semantic memory search के लिए OpenAI API key चाहिए?

सिर्फ तभी जब OpenAI embeddings उपयोग करते हैं। Codex OAuth chat/completions cover करता है और embeddings access grant नहीं करता, इसलिए Codex (OAuth या Codex CLI login) से sign in करना semantic memory search के लिए मदद नहीं करता। OpenAI embeddings को अभी भी real API key चाहिए (OPENAI_API_KEY या models.providers.openai.apiKey)।

अगर explicitly provider set नहीं करते, तो Mayros auto-select करता है जब API key resolve हो (auth profiles, models.providers.*.apiKey, या env vars)। OpenAI key resolve हो तो OpenAI prefer करता है, वरना Gemini key resolve हो तो Gemini। दोनों key available न हो तो memory search disabled रहता है जब तक configure न करें। Local model path configured और present हो तो Mayros local prefer करता है।

Local रहना चाहते हैं तो memorySearch.provider = "local" set करें (और optionally memorySearch.fallback = "none")। Gemini embeddings चाहिए तो memorySearch.provider = "gemini" set करें और GEMINI_API_KEY (या memorySearch.remote.apiKey) provide करें। हम OpenAI, Gemini, या local embedding models support करते हैं - setup details के लिए देखें Memory।

क्या memory हमेशा के लिए persist होती है? limits क्या हैं?

Memory files disk पर रहती हैं और delete करने तक persist होती हैं। Limit आपकी storage है, model नहीं। Session context अभी भी model context window से limited है, इसलिए लंबी conversations compact या truncate हो सकती हैं। इसीलिए memory search exist करती है - यह सिर्फ relevant parts context में वापस लाती है।

Docs: Memory, Context।

डिस्क पर चीज़ें कहां हैं

क्या Mayros के साथ उपयोग किया गया सारा data locally save होता है?

नहीं - Mayros की state local है, लेकिन external services अभी भी देखती हैं जो आप भेजते हैं।

  • Default रूप से Local: sessions, memory files, config, और workspace Gateway host पर रहते हैं (~/.mayros + आपकी workspace directory)।
  • ज़रूरत से Remote: model providers (Anthropic/OpenAI/etc.) को भेजे messages उनके APIs पर जाते हैं, और chat platforms (WhatsApp/Telegram/Slack/etc.) अपने servers पर message data store करते हैं।
  • आप footprint control करते हैं: local models उपयोग करने से prompts आपकी machine पर रहते हैं, लेकिन channel traffic अभी भी channel के servers से जाता है।

संबंधित: Agent workspace, Memory।

Mayros अपना data कहां store करता है?

सब कुछ $MAYROS_STATE_DIR (default: ~/.mayros) के अंदर रहता है:

PathPurpose
$MAYROS_STATE_DIR/mayros.jsonMain config (JSON5)
$MAYROS_STATE_DIR/credentials/oauth.jsonLegacy OAuth import (पहले use पर auth profiles में copy)
$MAYROS_STATE_DIR/agents/<agentId>/agent/auth-profiles.jsonAuth profiles (OAuth + API keys)
$MAYROS_STATE_DIR/agents/<agentId>/agent/auth.jsonRuntime auth cache (automatically managed)
$MAYROS_STATE_DIR/credentials/Provider state (उदा. whatsapp/<accountId>/creds.json)
$MAYROS_STATE_DIR/agents/Per-agent state (agentDir + sessions)
$MAYROS_STATE_DIR/agents/<agentId>/sessions/Conversation history & state (per agent)
$MAYROS_STATE_DIR/agents/<agentId>/sessions/sessions.jsonSession metadata (per agent)

Legacy single-agent path: ~/.mayros/agent/* (mayros doctor migrate करता है)।

आपका workspace (AGENTS.md, memory files, skills, etc.) अलग है और agents.defaults.workspace (default: ~/.mayros/workspace) से configured है।

AGENTS.md / MAYROS.md / USER.md / MEMORY.md कहां होने चाहिए?

ये files agent workspace में रहती हैं, ~/.mayros में नहीं।

  • Workspace (per agent): AGENTS.md, MAYROS.md, IDENTITY.md, USER.md, MEMORY.md (या memory.md), memory/YYYY-MM-DD.md, optional HEARTBEAT.md।
  • State dir (~/.mayros): config, credentials, auth profiles, sessions, logs, और shared skills (~/.mayros/skills)।

Default workspace ~/.mayros/workspace है, configurable:

json5
{
  agents: { defaults: { workspace: "~/.mayros/workspace" } },
}

अगर restart के बाद bot "भूल जाता है", तो confirm करें कि Gateway हर launch पर same workspace उपयोग कर रहा है (और याद रखें: remote mode gateway host का workspace उपयोग करता है, आपके local laptop का नहीं)।

टिप: durable behavior या preference चाहिए तो bot से कहें AGENTS.md या MEMORY.md में लिखो chat history पर depend करने की बजाय।

देखें Agent workspace और Memory।

अनुशंसित backup strategy क्या है?

अपना agent workspace एक private git repo में रखें और कहीं private backup करें (उदाहरण GitHub private)। इससे memory + AGENTS/MAYROS/USER files capture होती हैं, और बाद में assistant का "mind" restore कर सकते हैं।

~/.mayros (credentials, sessions, tokens) के अंदर कुछ भी commit न करें। Full restore चाहिए तो workspace और state directory दोनों separately backup करें (ऊपर migration question देखें)।

Docs: Agent workspace।

Mayros को पूरी तरह uninstall कैसे करें?

Dedicated guide देखें: Uninstall।

क्या agents workspace के बाहर काम कर सकते हैं?

हां। Workspace default cwd और memory anchor है, hard sandbox नहीं। Relative paths workspace के अंदर resolve होते हैं, लेकिन absolute paths अन्य host locations access कर सकते हैं जब तक sandboxing enabled न हो। Isolation चाहिए तो agents.defaults.sandbox या per-agent sandbox settings उपयोग करें। Repo को default working directory बनाना चाहते हैं तो उस agent का workspace repo root पर point करें। Mayros repo सिर्फ source code है; जब तक intentionally agent को उसके अंदर काम करवाना न चाहें, workspace अलग रखें।

Example (repo default cwd के रूप में):

json5
{
  agents: {
    defaults: {
      workspace: "~/Projects/my-repo",
    },
  },
}

मैं remote mode में हूं - session store कहां है?

Session state gateway host का है। Remote mode में हैं तो जो session store matter करता है वह remote machine पर है, आपके local laptop पर नहीं। देखें Session management।

Config basics

config का format क्या है? कहां है?

Mayros $MAYROS_CONFIG_PATH (default: ~/.mayros/mayros.json) से optional JSON5 config पढ़ता है:

$MAYROS_CONFIG_PATH

File missing हो तो safe-ish defaults उपयोग करता है (default workspace ~/.mayros/workspace सहित)।

gateway.bind: "lan" (या "tailnet") set किया और अब कुछ listen नहीं हो रहा / UI unauthorized कहता है

Non-loopback binds को auth चाहिए। gateway.auth.mode + gateway.auth.token configure करें (या MAYROS_GATEWAY_TOKEN उपयोग करें)।

json5
{
  gateway: {
    bind: "lan",
    auth: {
      mode: "token",
      token: "replace-me",
    },
  },
}

Notes:

  • gateway.remote.token सिर्फ remote CLI calls के लिए है; local gateway auth enable नहीं करता।
  • Control UI connect.params.auth.token (app/UI settings में stored) से authenticate करता है। URLs में tokens रखने से बचें।

localhost पर अब token क्यों चाहिए?

Mayros default रूप से token auth enforce करता है, loopback सहित। कोई token configured नहीं तो gateway startup auto-generate करता है और gateway.auth.token में save करता है, इसलिए local WS clients को authenticate करना होगा। यह अन्य local processes को Gateway call करने से block करता है।

अगर सच में open loopback चाहिए, तो config में explicitly gateway.auth.mode: "none" set करें। Doctor कभी भी token generate कर सकता है: mayros doctor --generate-gateway-token।

config बदलने के बाद restart करना ज़रूरी है?

Gateway config watch करता है और hot-reload support करता है:

  • gateway.reload.mode: "hybrid" (default): safe changes hot-apply, critical ones के लिए restart
  • hot, restart, off भी supported हैं

web search (और web fetch) कैसे enable करें?

web_fetch बिना API key के काम करता है। web_search को Brave Search API key चाहिए। अनुशंसित: इसे tools.web.search.apiKey में store करने के लिए mayros configure --section web चलाएं। Environment alternative: Gateway process के लिए BRAVE_API_KEY set करें।

json5
{
  tools: {
    web: {
      search: {
        enabled: true,
        apiKey: "BRAVE_API_KEY_HERE",
        maxResults: 5,
      },
      fetch: {
        enabled: true,
      },
    },
  },
}

Notes:

  • Allowlists उपयोग करते हैं तो web_search/web_fetch या group:web जोड़ें।
  • web_fetch default रूप से enabled है (जब तक explicitly disabled न हो)।
  • Daemons ~/.mayros/.env (या service environment) से env vars पढ़ते हैं।

Docs: Web tools।

config.apply ने मेरा config मिटा दिया। कैसे recover करें और इससे कैसे बचें?

config.apply पूरा config replace करता है। Partial object भेजने पर बाकी सब remove हो जाता है।

Recover:

  • Backup से restore करें (git या copied ~/.mayros/mayros.json)।
  • Backup नहीं है तो mayros doctor re-run करें और channels/models reconfigure करें।
  • Unexpected था तो bug file करें और last known config या कोई backup शामिल करें।
  • Local coding agent अक्सर logs या history से working config reconstruct कर सकता है।

बचाव:

  • छोटे changes के लिए mayros config set उपयोग करें।
  • Interactive edits के लिए mayros configure उपयोग करें।

Docs: Config, Configure, Doctor।

पहले install के लिए minimal "sane" config क्या है?

json5
{
  agents: { defaults: { workspace: "~/.mayros/workspace" } },
  channels: { whatsapp: { allowFrom: ["+15555550123"] } },
}

यह workspace set करता है और restrict करता है कि bot को कौन trigger कर सकता है।

devices के बीच specialized workers के साथ central Gateway कैसे चलाएं?

Common pattern एक Gateway (उदा. Raspberry Pi) plus nodes और agents है:

  • Gateway (central): channels (Signal/WhatsApp), routing, और sessions own करता है।
  • Nodes (devices): Macs/iOS/Android peripherals के रूप में connect होते हैं और local tools expose करते हैं (system.run, canvas, camera)।
  • Agents (workers): special roles के लिए अलग brains/workspaces (उदा. "Hetzner ops", "Personal data")।
  • Sub-agents: parallelism चाहिए तो main agent से background work spawn करें।
  • TUI: Gateway से connect करें और agents/sessions switch करें।

Docs: Nodes, Remote access, Multi-Agent Routing, Sub-agents, TUI।

क्या Mayros browser headless चल सकता है?

हां। Config option है:

json5
{
  browser: { headless: true },
  agents: {
    defaults: {
      sandbox: { browser: { headless: true } },
    },
  },
}

Default false (headful) है। Headless कुछ sites पर anti-bot checks trigger करने की ज़्यादा संभावना है। देखें Browser।

Headless same Chromium engine उपयोग करता है और अधिकांश automation (forms, clicks, scraping, logins) के लिए काम करता है। मुख्य अंतर:

  • कोई visible browser window नहीं (visuals चाहिए तो screenshots उपयोग करें)।
  • कुछ sites headless mode में automation के बारे में stricter हैं (CAPTCHAs, anti-bot)। उदाहरण, X/Twitter अक्सर headless sessions block करता है।

browser control के लिए Brave कैसे उपयोग करें?

browser.executablePath को अपनी Brave binary (या कोई Chromium-based browser) पर set करें और Gateway restart करें। Full config examples देखें Browser में।

Remote gateways और nodes

Telegram, gateway और nodes के बीच commands कैसे propagate होते हैं?

Telegram messages gateway handle करता है। Gateway agent चलाता है और node tool ज़रूरत होने पर Gateway WebSocket से nodes call करता है:

Telegram → Gateway → Agent → node.* → Node → Gateway → Telegram

Nodes inbound provider traffic नहीं देखते; वे सिर्फ node RPC calls receive करते हैं।

Gateway remotely hosted है तो agent मेरे computer को कैसे access करे?

संक्षिप्त उत्तर: अपने computer को node के रूप में pair करें। Gateway कहीं और चलता है, लेकिन Gateway WebSocket से आपकी local machine पर node.* tools (screen, camera, system) call कर सकता है।

Typical setup:

  1. Always-on host (VPS/home server) पर Gateway चलाएं।

  2. Gateway host + आपका computer same tailnet पर रखें।

  3. Gateway WS reachable सुनिश्चित करें (tailnet bind या SSH tunnel)।

  4. Locally macOS app खोलें और Remote over SSH mode (या direct tailnet) में connect करें ताकि node के रूप में register हो सके।

  5. Gateway पर node approve करें:

    bash
    mayros nodes pending
mayros nodes approve <requestId>

कोई separate TCP bridge ज़रूरी नहीं; nodes Gateway WebSocket से connect होते हैं।

Security reminder: macOS node pair करना उस machine पर system.run allow करता है। सिर्फ trusted devices pair करें, और Security review करें।

Docs: Nodes, Gateway protocol, macOS remote mode, Security।

Tailscale connected है लेकिन कोई reply नहीं आ रहा। अब क्या?

Basics चेक करें:

  • Gateway चल रहा है: mayros gateway status
  • Gateway health: mayros status
  • Channel health: mayros channels status

फिर auth और routing verify करें:

  • Tailscale Serve उपयोग करते हैं तो gateway.auth.allowTailscale correctly set सुनिश्चित करें।
  • SSH tunnel से connect करते हैं तो local tunnel up confirm करें और सही port पर point कर रहा हो।
  • Allowlists (DM या group) में आपका account शामिल confirm करें।

Docs: Tailscale, Remote access, Channels।

क्या दो Mayros instances एक-दूसरे से बात कर सकते हैं (local + VPS)?

हां। Built-in "bot-to-bot" bridge नहीं है, लेकिन कुछ reliable तरीकों से wire कर सकते हैं:

सबसे simple: एक normal chat channel उपयोग करें जो दोनों bots access कर सकें (Telegram/Slack/WhatsApp)। Bot A से Bot B को message भेजवाएं, फिर Bot B हमेशा की तरह reply करे।

CLI bridge (generic): दूसरे Gateway को mayros agent --message ... --deliver से call करने वाली script चलाएं, उस chat को target करें जहां दूसरा bot listen कर रहा हो। एक bot remote VPS पर है तो SSH/Tailscale से CLI उस remote Gateway पर point करें (देखें Remote access)।

Example pattern (target Gateway reach कर सकने वाली machine से चलाएं):

bash
mayros agent --message "Hello from local bot" --deliver --channel telegram --reply-to <chat-id>

टिप: guardrail जोड़ें ताकि दो bots endlessly loop न करें (mention-only, channel allowlists, या "bot messages को reply मत करो" rule)।

Docs: Remote access, Agent CLI, Agent send।

क्या multiple agents के लिए अलग-अलग VPSes चाहिए?

नहीं। एक Gateway multiple agents host कर सकता है, प्रत्येक अपने workspace, model defaults, और routing के साथ। यह normal setup है और per agent एक VPS चलाने से बहुत cheaper और simpler है।

Separate VPSes सिर्फ तभी उपयोग करें जब hard isolation (security boundaries) या बहुत अलग configs चाहिए जो share नहीं करना चाहते। अन्यथा एक Gateway रखें और multiple agents या sub-agents उपयोग करें।

VPS से SSH की बजाय personal laptop पर node उपयोग करने का फायदा है?

हां - nodes remote Gateway से आपके laptop तक पहुंचने का first-class तरीका हैं, और shell access से ज़्यादा unlock करते हैं। Gateway macOS/Linux (Windows WSL2 से) पर चलता है और lightweight है (छोटा VPS या Raspberry Pi-class box ठीक; 4 GB RAM पर्याप्त), इसलिए common setup always-on host plus laptop as node है।

  • कोई inbound SSH ज़रूरी नहीं। Nodes Gateway WebSocket से outbound connect करते हैं और device pairing उपयोग करते हैं।
  • Safer execution controls। system.run उस laptop पर node allowlists/approvals से gated है।
  • ज़्यादा device tools। Nodes system.run के अलावा canvas, camera, और screen expose करते हैं।
  • Local browser automation। Gateway VPS पर रखें, लेकिन Chrome locally चलाएं और Chrome extension + laptop पर node host से control relay करें।

SSH ad-hoc shell access के लिए ठीक है, लेकिन ongoing agent workflows और device automation के लिए nodes simpler हैं।

Docs: Nodes, Nodes CLI, Chrome extension।

दूसरे laptop पर install करूं या बस node जोड़ूं?

अगर दूसरे laptop पर सिर्फ local tools (screen/camera/exec) चाहिए, तो node जोड़ें। इससे single Gateway रहता है और duplicated config से बचते हैं। Local node tools अभी macOS-only हैं, लेकिन अन्य OSes पर extend करने की योजना है।

दूसरा Gateway तभी install करें जब hard isolation या दो पूरी तरह separate bots चाहिए।

Docs: Nodes, Nodes CLI, Multiple gateways।

क्या nodes gateway service चलाते हैं?

नहीं। प्रति host सिर्फ एक gateway चलना चाहिए जब तक intentionally isolated profiles न चलाएं (देखें Multiple gateways)। Nodes peripherals हैं जो gateway से connect होते हैं (iOS/Android nodes, या macOS menubar app में "node mode")। Headless node hosts और CLI control के लिए देखें Node host CLI।

gateway, discovery, और canvasHost changes के लिए full restart ज़रूरी है।

क्या config apply करने का API / RPC तरीका है?

हां। config.apply validate + write करता है full config और operation के हिस्से के रूप में Gateway restart करता है।

config.apply ने मेरा config मिटा दिया। कैसे recover करें और इससे कैसे बचें?

config.apply पूरा config replace करता है। Partial object भेजने पर बाकी सब remove हो जाता है।

Recover:

  • Backup से restore करें (git या copied ~/.mayros/mayros.json)।
  • Backup नहीं है तो mayros doctor re-run करें और channels/models reconfigure करें।
  • Unexpected था तो bug file करें और last known config या backup शामिल करें।
  • Local coding agent अक्सर logs या history से working config reconstruct कर सकता है।

बचाव:

  • छोटे changes के लिए mayros config set उपयोग करें।
  • Interactive edits के लिए mayros configure उपयोग करें।

Docs: Config, Configure, Doctor।

VPS पर Tailscale कैसे सेटअप करें और Mac से कैसे connect करें?

Minimal steps:

  1. VPS पर Install + login

    bash
    curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up

  2. Mac पर Install + login

    • Tailscale app उपयोग करें और same tailnet में sign in करें।

  3. MagicDNS enable करें (अनुशंसित)

    • Tailscale admin console में MagicDNS enable करें ताकि VPS का stable name हो।

  4. Tailnet hostname उपयोग करें

बिना SSH Control UI चाहिए तो VPS पर Tailscale Serve उपयोग करें:

bash
mayros gateway --tailscale serve

इससे gateway loopback पर bound रहता है और Tailscale से HTTPS expose होता है। देखें Tailscale।

Mac node को remote Gateway (Tailscale Serve) से कैसे connect करें?

Serve Gateway Control UI + WS expose करता है। Nodes same Gateway WS endpoint से connect होते हैं।

अनुशंसित setup:

  1. VPS + Mac same tailnet पर सुनिश्चित करें।

  2. macOS app Remote mode में उपयोग करें (SSH target tailnet hostname हो सकता है)। App Gateway port tunnel करेगा और node के रूप में connect करेगा।

  3. Gateway पर node approve करें:

    bash
    mayros nodes pending
mayros nodes approve <requestId>

Docs: Gateway protocol, Discovery, macOS remote mode।

Env vars और .env loading

Mayros environment variables कैसे load करता है?

Mayros parent process (shell, launchd/systemd, CI, etc.) से env vars पढ़ता है और additionally load करता है:

  • Current working directory से .env
  • ~/.mayros/.env (aka $MAYROS_STATE_DIR/.env) से global fallback .env

कोई भी .env file existing env vars override नहीं करती।

Config में inline env vars भी define कर सकते हैं (process env से missing होने पर ही apply):

json5
{
  env: {
    OPENROUTER_API_KEY: "sk-or-...",
    vars: { GROQ_API_KEY: "gsk-..." },
  },
}

देखें /environment full precedence और sources के लिए।

"service से Gateway शुरू किया और env vars गायब हो गए।" अब क्या?

दो common fixes:

  1. Missing keys ~/.mayros/.env में रखें ताकि service आपके shell env inherit न करे तब भी pick हों।
  2. Shell import enable करें (opt-in convenience):
json5
{
  env: {
    shellEnv: {
      enabled: true,
      timeoutMs: 15000,
    },
  },
}

यह login shell चलाता है और सिर्फ missing expected keys import करता है (कभी override नहीं)। Env var equivalents: MAYROS_LOAD_SHELL_ENV=1, MAYROS_SHELL_ENV_TIMEOUT_MS=15000।

COPILOT_GITHUB_TOKEN set किया, लेकिन models status "Shell env: off" दिखाता है। क्यों?

mayros models status report करता है कि shell env import enabled है या नहीं। "Shell env: off" का मतलब नहीं है कि env vars missing हैं - इसका मतलब बस Mayros automatically login shell load नहीं करेगा।

Gateway service (launchd/systemd) के रूप में चलता है तो shell environment inherit नहीं करेगा। Fix इनमें से एक करके:

  1. Token ~/.mayros/.env में रखें:

    COPILOT_GITHUB_TOKEN=...

  2. या shell import enable करें (env.shellEnv.enabled: true)।

  3. या config env block में जोड़ें (missing होने पर ही apply)।

फिर gateway restart करें और recheck करें:

bash
mayros models status

Copilot tokens COPILOT_GITHUB_TOKEN से पढ़े जाते हैं (GH_TOKEN / GITHUB_TOKEN भी)। देखें /concepts/model-providers और /environment।

Sessions और multiple chats

नई बातचीत कैसे शुरू करें?

Standalone message के रूप में /new या /reset भेजें। देखें Session management।

क्या /new न भेजने पर sessions अपने आप reset होते हैं?

हां। Sessions session.idleMinutes (default 60) के बाद expire होते हैं। अगला message उस chat key के लिए नया session id शुरू करता है। इससे transcripts delete नहीं होते - बस नया session शुरू होता है।

json5
{
  session: {
    idleMinutes: 240,
  },
}

क्या Mayros instances की team बना सकते हैं - एक CEO और कई agents?

हां, multi-agent routing और sub-agents से। एक coordinator agent और कई worker agents बना सकते हैं अपने workspaces और models के साथ।

कहा गया कि, यह सबसे अच्छा fun experiment के रूप में देखा जाता है। यह token heavy है और अक्सर एक bot separate sessions के साथ उपयोग करने से कम efficient। Typical model जो हम envision करते हैं: एक bot जिससे बात करें, parallel work के लिए अलग sessions। वह bot ज़रूरत पड़ने पर sub-agents भी spawn कर सकता है।

Docs: Multi-agent routing, Sub-agents, Agents CLI।

task के बीच context truncate क्यों हुआ? कैसे रोकें?

Session context model window से limited है। लंबी chats, बड़े tool outputs, या कई files compaction या truncation trigger कर सकते हैं।

क्या मदद करता है:

  • Bot से current state summarize करवाएं और file में लिखवाएं।
  • लंबे tasks से पहले /compact उपयोग करें, और topics switch करते समय /new।
  • Important context workspace में रखें और bot से वापस पढ़वाएं।
  • Main chat छोटी रखने के लिए लंबे या parallel work के लिए sub-agents उपयोग करें।
  • बार-बार होता है तो larger context window वाला model चुनें।

installed रखते हुए Mayros को पूरी तरह reset कैसे करें?

Reset command उपयोग करें:

bash
mayros reset

Non-interactive full reset:

bash
mayros reset --scope full --yes --non-interactive

फिर onboarding re-run करें:

bash
mayros onboard --install-daemon

Notes:

  • Onboarding wizard existing config देखने पर Reset offer भी करता है। देखें Wizard।
  • Profiles (--profile / MAYROS_PROFILE) उपयोग किया तो प्रत्येक state dir reset करें (defaults ~/.mayros-<profile> हैं)।
  • Dev reset: mayros gateway --dev --reset (dev-only; dev config + credentials + sessions + workspace wipe)।

"context too large" errors आ रही हैं - कैसे reset या compact करें?

इनमें से एक उपयोग करें:

  • Compact (conversation रखता है लेकिन पुरानी turns summarize करता है):

    /compact

    या /compact <instructions> summary guide करने के लिए।

  • Reset (same chat key के लिए fresh session ID):

    /new
/reset

बार-बार होता है तो:

  • Session pruning enable या tune करें (agents.defaults.contextPruning) पुराने tool output trim करने के लिए।
  • Larger context window वाला model उपयोग करें।

Docs: Compaction, Session pruning, Session management।

"LLM request rejected: messages.content.tool_use.input field required" क्यों दिख रहा है?

यह provider validation error है: model ने required input बिना tool_use block emit किया। आमतौर पर session history stale या corrupted है (अक्सर लंबे threads या tool/schema change के बाद)।

Fix: /new (standalone message) से fresh session शुरू करें।

हर 30 मिनट में heartbeat messages क्यों आ रहे हैं?

Heartbeats default रूप से हर 30m चलते हैं। Tune या disable करें:

json5
{
  agents: {
    defaults: {
      heartbeat: {
        every: "2h", // या disable करने के लिए "0m"
      },
    },
  },
}

अगर HEARTBEAT.md exist करता है लेकिन effectively empty है (सिर्फ blank lines और markdown headers जैसे # Heading), तो Mayros API calls बचाने के लिए heartbeat run skip करता है। File missing है तो heartbeat अभी भी चलता है और model decide करता है क्या करना है।

Per-agent overrides agents.list[].heartbeat उपयोग करते हैं। Docs: Heartbeat।

क्या WhatsApp group में "bot account" जोड़ना ज़रूरी है?

नहीं। Mayros आपके अपने account पर चलता है, इसलिए group में हैं तो Mayros देख सकता है। Default रूप से group replies blocked हैं जब तक senders allow न करें (groupPolicy: "allowlist")।

सिर्फ आप group replies trigger कर सकें ऐसा चाहते हैं:

json5
{
  channels: {
    whatsapp: {
      groupPolicy: "allowlist",
      groupAllowFrom: ["+15551234567"],
    },
  },
}

WhatsApp group का JID कैसे पता करें?

Option 1 (सबसे तेज़): logs tail करें और group में test message भेजें:

bash
mayros logs --follow --json

chatId (या from) देखें जो @g.us से end हो, जैसे: [email protected]।

Option 2 (अगर पहले से configured/allowlisted): config से groups list करें:

bash
mayros directory groups list --channel whatsapp

Docs: WhatsApp, Directory, Logs।

Mayros group में reply क्यों नहीं करता?

दो common कारण:

  • Mention gating on है (default)। Bot को @mention करना होगा (या mentionPatterns match)।
  • channels.whatsapp.groups "*" बिना configure किया और group allowlisted नहीं है।

देखें Groups और Group messages।

क्या groups/threads DMs के साथ context share करते हैं?

Direct chats default रूप से main session में collapse होती हैं। Groups/channels के अपने session keys होते हैं, और Telegram topics / Discord threads separate sessions हैं। देखें Groups और Group messages।

कितने workspaces और agents बना सकता हूं?

कोई hard limits नहीं। Dozens (यहां तक कि hundreds) ठीक हैं, लेकिन ध्यान रखें:

  • Disk growth: sessions + transcripts ~/.mayros/agents/<agentId>/sessions/ में रहते हैं।
  • Token cost: ज़्यादा agents मतलब ज़्यादा concurrent model usage।
  • Ops overhead: per-agent auth profiles, workspaces, और channel routing।

Tips:

  • प्रति agent एक active workspace रखें (agents.defaults.workspace)।
  • Disk बढ़े तो पुराने sessions prune करें (JSONL या store entries delete)।
  • Stray workspaces और profile mismatches spot करने के लिए mayros doctor उपयोग करें।

क्या एक ही समय में multiple bots या chats चला सकता हूं (Slack), और कैसे सेटअप करें?

हां। Multiple isolated agents चलाने और inbound messages को channel/account/peer से route करने के लिए Multi-Agent Routing उपयोग करें। Slack channel के रूप में supported है और specific agents से bind हो सकता है।

Browser access powerful है लेकिन "कुछ भी human कर सके" नहीं - anti-bot, CAPTCHAs, और MFA अभी भी automation block कर सकते हैं। सबसे reliable browser control के लिए browser चलाने वाली machine पर Chrome extension relay उपयोग करें (और Gateway कहीं भी रखें)।

Best-practice setup:

  • Always-on Gateway host (VPS/Mac mini)।
  • प्रति role एक agent (bindings)।
  • उन agents से bound Slack channel(s)।
  • ज़रूरत पड़ने पर extension relay (या node) से local browser।

Docs: Multi-Agent Routing, Slack, Browser, Chrome extension, Nodes।

Models: defaults, selection, aliases, switching

"default model" क्या है?

Mayros का default model वह है जो आप set करें:

agents.defaults.model.primary

Models provider/model (उदाहरण: anthropic/claude-opus-4-6) के रूप में reference होते हैं। Provider omit करते हैं तो Mayros temporary deprecation fallback के रूप में anthropic assume करता है - लेकिन फिर भी explicitly provider/model set करना चाहिए।

कौन सा model recommend करते हैं?

अनुशंसित default: anthropic/claude-opus-4-6। अच्छा alternative: anthropic/claude-sonnet-4-5। Reliable (कम personality): openai/gpt-5.2 - Opus जितना ही अच्छा, बस कम personality। Budget: zai/glm-4.7।

MiniMax M2.1 के अपने docs हैं: MiniMax और Local models।

अंगूठे का नियम: high-stakes work के लिए सबसे अच्छा model जो afford कर सकें उपयोग करें, और routine chat या summaries के लिए cheaper model। Per agent models route कर सकते हैं और लंबे tasks parallelize करने के लिए sub-agents उपयोग करें (हर sub-agent tokens consume करता है)। देखें Models और Sub-agents।

Strong warning: कमज़ोर/over-quantized models prompt injection और unsafe behavior के लिए ज़्यादा vulnerable हैं। देखें Security।

अधिक context: Models।

क्या self-hosted models (llama.cpp, vLLM, Ollama) उपयोग कर सकता हूं?

हां। अगर local server OpenAI-compatible API expose करता है, तो custom provider उस पर point कर सकते हैं। Ollama directly supported है और सबसे आसान path है।

Security note: छोटे या heavily quantized models prompt injection के लिए ज़्यादा vulnerable हैं। Tools उपयोग कर सकने वाले किसी भी bot के लिए बड़े models strongly recommend करते हैं। छोटे models फिर भी चाहते हैं तो sandboxing और strict tool allowlists enable करें।

Docs: Ollama, Local models, Model providers, Security, Sandboxing।

config मिटाए बिना models कैसे switch करें?

Model commands उपयोग करें या सिर्फ model fields edit करें। Full config replaces से बचें।

Safe options:

  • Chat में /model (quick, per-session)
  • mayros models set ... (सिर्फ model config update)
  • mayros configure --section model (interactive)
  • ~/.mayros/mayros.json में agents.defaults.model edit करें

Partial object से config.apply से बचें जब तक पूरा config replace करने का intent न हो। Config overwrite हो गया तो backup से restore करें या repair के लिए mayros doctor re-run करें।

Docs: Models, Configure, Config, Doctor।

Mayros, Flawd और Krill models के लिए क्या उपयोग करते हैं?

  • Mayros + Flawd: Anthropic Opus (anthropic/claude-opus-4-6) - देखें Anthropic।
  • Krill: MiniMax M2.1 (minimax/MiniMax-M2.1) - देखें MiniMax।

बिना restart के models कैसे switch करें (on the fly)?

Standalone message के रूप में /model command उपयोग करें:

/model sonnet
/model haiku
/model opus
/model gpt
/model gpt-mini
/model gemini
/model gemini-flash

Available models /model, /model list, या /model status से list कर सकते हैं।

/model (और /model list) compact, numbered picker दिखाता है। Number से select करें:

/model 3

Provider के लिए specific auth profile force भी कर सकते हैं (per session):

/model opus@anthropic:default
/model opus@anthropic:work

टिप: /model status दिखाता है कौन सा agent active है, कौन सी auth-profiles.json file उपयोग हो रही है, और अगला कौन सा auth profile try होगा। Configured provider endpoint (baseUrl) और API mode (api) भी available होने पर दिखाता है।

profile से set किया profile कैसे unpin करें?

@profile suffix बिना /model re-run करें:

/model anthropic/claude-opus-4-6

Default पर वापस जाना चाहते हैं तो /model से चुनें (या /model <default provider/model> भेजें)। कौन सा auth profile active है confirm करने के लिए /model status उपयोग करें।

क्या daily tasks के लिए GPT 5.2 और coding के लिए Codex 5.3 उपयोग कर सकता हूं?

हां। एक default set करें और ज़रूरत अनुसार switch करें:

  • Quick switch (per session): daily tasks के लिए /model gpt-5.2, coding के लिए /model gpt-5.3-codex।
  • Default + switch: agents.defaults.model.primary को openai/gpt-5.2 set करें, फिर coding करते समय openai-codex/gpt-5.3-codex पर switch करें (या उल्टा)।
  • Sub-agents: different default model वाले sub-agents को coding tasks route करें।

देखें Models और Slash commands।

"Model … is not allowed" क्यों दिखता है और फिर कोई reply नहीं?

अगर agents.defaults.models set है, तो यह /model और किसी भी session overrides के लिए allowlist बन जाता है। उस list में नहीं वाला model चुनने पर:

Model "provider/model" is not allowed. Use /model to list available models.

यह error normal reply की बजाय return होता है। Fix: model agents.defaults.models में जोड़ें, allowlist remove करें, या /model list से model चुनें।

"Unknown model: minimax/MiniMax-M2.1" क्यों दिखता है?

इसका मतलब provider configured नहीं है (कोई MiniMax provider config या auth profile नहीं मिला), इसलिए model resolve नहीं हो सकता। इस detection का fix 2026.1.12 (लिखते समय unreleased) में है।

Fix checklist:

  1. 2026.1.12 पर upgrade करें (या source main से चलाएं), फिर gateway restart करें।

  2. MiniMax configured सुनिश्चित करें (wizard या JSON), या MiniMax API key env/auth profiles में exist करे ताकि provider inject हो सके।

  3. Exact model id (case-sensitive) उपयोग करें: minimax/MiniMax-M2.1 या minimax/MiniMax-M2.1-lightning।

  4. चलाएं:

    bash
    mayros models list

    और list से चुनें (या chat में /model list)।

देखें MiniMax और Models।

क्या MiniMax को default और OpenAI को complex tasks के लिए उपयोग कर सकता हूं?

हां। MiniMax default उपयोग करें और ज़रूरत पड़ने पर per session models switch करें। Fallbacks errors के लिए हैं, "hard tasks" के लिए नहीं, इसलिए /model या separate agent उपयोग करें।

Option A: per session switch

json5
{
  env: { MINIMAX_API_KEY: "sk-...", OPENAI_API_KEY: "sk-..." },
  agents: {
    defaults: {
      model: { primary: "minimax/MiniMax-M2.1" },
      models: {
        "minimax/MiniMax-M2.1": { alias: "minimax" },
        "openai/gpt-5.2": { alias: "gpt" },
      },
    },
  },
}

फिर:

/model gpt

Option B: separate agents

  • Agent A default: MiniMax
  • Agent B default: OpenAI
  • Agent से route करें या switch करने के लिए /agent उपयोग करें

Docs: Models, Multi-Agent Routing, MiniMax, OpenAI।

क्या opus / sonnet / gpt built-in shortcuts हैं?

हां। Mayros कुछ default shorthands ship करता है (तभी apply जब model agents.defaults.models में exist करे):

  • opus → anthropic/claude-opus-4-6
  • sonnet → anthropic/claude-sonnet-4-5
  • gpt → openai/gpt-5.2
  • gpt-mini → openai/gpt-5-mini
  • gemini → google/gemini-3-pro-preview
  • gemini-flash → google/gemini-3-flash-preview

Same name से अपना alias set करते हैं तो आपकी value जीतती है।

model shortcuts (aliases) कैसे define/override करें?

Aliases agents.defaults.models.<modelId>.alias से आते हैं। उदाहरण:

json5
{
  agents: {
    defaults: {
      model: { primary: "anthropic/claude-opus-4-6" },
      models: {
        "anthropic/claude-opus-4-6": { alias: "opus" },
        "anthropic/claude-sonnet-4-5": { alias: "sonnet" },
        "anthropic/claude-haiku-4-5": { alias: "haiku" },
      },
    },
  },
}

फिर /model sonnet (या /<alias> supported होने पर) उस model ID में resolve होता है।

OpenRouter या Z.AI जैसे providers से models कैसे जोड़ें?

OpenRouter (pay-per-token; कई models):

json5
{
  agents: {
    defaults: {
      model: { primary: "openrouter/anthropic/claude-sonnet-4-5" },
      models: { "openrouter/anthropic/claude-sonnet-4-5": {} },
    },
  },
  env: { OPENROUTER_API_KEY: "sk-or-..." },
}

Z.AI (GLM models):

json5
{
  agents: {
    defaults: {
      model: { primary: "zai/glm-4.7" },
      models: { "zai/glm-4.7": {} },
    },
  },
  env: { ZAI_API_KEY: "..." },
}

Provider/model reference करते हैं लेकिन required provider key missing है तो runtime auth error मिलेगा (उदा. No API key found for provider "zai")।

नया agent जोड़ने के बाद No API key found for provider

आमतौर पर नए agent का auth store empty है। Auth per-agent है और यहां stored है:

~/.mayros/agents/<agentId>/agent/auth-profiles.json

Fix options:

  • mayros agents add <id> चलाएं और wizard में auth configure करें।
  • या main agent के agentDir से auth-profiles.json नए agent के agentDir में copy करें।

Agents में agentDir reuse न करें; auth/session collisions होती हैं।

Model failover और "All models failed"

failover कैसे काम करता है?

Failover दो stages में होता है:

  1. Same provider के अंदर Auth profile rotation।
  2. agents.defaults.model.fallbacks में अगले model पर Model fallback।

Failing profiles पर cooldowns apply होते हैं (exponential backoff), ताकि provider rate-limited या temporarily failing होने पर भी Mayros respond करता रहे।

इस error का क्या मतलब है?

No credentials found for profile "anthropic:default"

इसका मतलब system ने auth profile ID anthropic:default उपयोग करने का प्रयास किया, लेकिन expected auth store में credentials नहीं मिले।

No credentials found for profile "anthropic:default" के लिए fix checklist

  • Confirm करें auth profiles कहां हैं (new vs legacy paths)
    • Current: ~/.mayros/agents/<agentId>/agent/auth-profiles.json
    • Legacy: ~/.mayros/agent/* (mayros doctor migrate करता है)
  • Confirm करें env var Gateway load कर रहा है
    • Shell में ANTHROPIC_API_KEY set किया लेकिन Gateway systemd/launchd से चलाते हैं तो inherit नहीं हो सकता। ~/.mayros/.env में रखें या env.shellEnv enable करें।
  • सही agent edit कर रहे हैं सुनिश्चित करें
    • Multi-agent setups में multiple auth-profiles.json files हो सकती हैं।
  • Model/auth status sanity-check
    • Configured models और providers authenticated हैं या नहीं देखने के लिए mayros models status उपयोग करें।

No credentials found for profile "anthropic" के लिए fix checklist

Run Anthropic auth profile पर pinned है, लेकिन Gateway अपने auth store में नहीं ढूंढ पा रहा।

  • Setup-token उपयोग करें

    • claude setup-token चलाएं, फिर mayros models auth setup-token --provider anthropic से paste करें।
    • Token दूसरी machine पर बनाया तो mayros models auth paste-token --provider anthropic उपयोग करें।

  • API key उपयोग करना चाहते हैं तो

    • ANTHROPIC_API_KEY gateway host पर ~/.mayros/.env में रखें।

    • Missing profile force करने वाला pinned order clear करें:

      bash
      mayros models auth order clear --provider anthropic

  • Gateway host पर commands चला रहे हैं confirm करें

    • Remote mode में auth profiles gateway machine पर हैं, आपके laptop पर नहीं।

Google Gemini भी try क्यों किया और fail हुआ?

Model config में Google Gemini fallback के रूप में है (या Gemini shorthand पर switch किया) तो Mayros model fallback में try करेगा। Google credentials configure नहीं किए तो No API key found for provider "google" दिखेगा।

Fix: Google auth provide करें, या agents.defaults.model.fallbacks / aliases से Google models remove/avoid करें ताकि fallback वहां route न करे।

LLM request rejected message thinking signature required google antigravity

कारण: session history में बिना signatures वाले thinking blocks हैं (अक्सर aborted/partial stream से)। Google Antigravity thinking blocks के लिए signatures require करता है।

Fix: Mayros अब Google Antigravity Claude के लिए unsigned thinking blocks strip करता है। अभी भी दिखे तो नया session शुरू करें या उस agent के लिए /thinking off set करें।

Auth profiles: ये क्या हैं और कैसे manage करें

संबंधित: /concepts/oauth (OAuth flows, token storage, multi-account patterns)

auth profile क्या है?

Auth profile एक named credential record (OAuth या API key) है जो provider से tied है। Profiles यहां रहते हैं:

~/.mayros/agents/<agentId>/agent/auth-profiles.json

typical profile IDs क्या हैं?

Mayros provider-prefixed IDs उपयोग करता है जैसे:

  • anthropic:default (common जब कोई email identity नहीं)
  • anthropic:<email> OAuth identities के लिए
  • आपके चुने custom IDs (उदा. anthropic:work)

कौन सा auth profile पहले try हो, क्या control कर सकता हूं?

हां। Config profiles के लिए optional metadata और प्रति provider ordering (auth.order.<provider>) support करता है। यह secrets store नहीं करता; IDs को provider/mode से map करता है और rotation order set करता है।

Mayros temporarily profile skip कर सकता है अगर short cooldown (rate limits/timeouts/auth failures) या longer disabled state (billing/insufficient credits) में हो। Inspect करने के लिए mayros models status --json चलाएं और auth.unusableProfiles चेक करें। Tuning: auth.cooldowns.billingBackoffHours*।

CLI से per-agent order override भी set कर सकते हैं (उस agent की auth-profiles.json में stored):

bash
# Configured default agent पर defaults (--agent omit करें)
mayros models auth order get --provider anthropic

# Single profile पर rotation lock करें (सिर्फ यही try)
mayros models auth order set --provider anthropic anthropic:default

# या explicit order set करें (provider के अंदर fallback)
mayros models auth order set --provider anthropic anthropic:work anthropic:default

# Override clear करें (config auth.order / round-robin पर fallback)
mayros models auth order clear --provider anthropic

Specific agent target करने के लिए:

bash
mayros models auth order set --provider anthropic --agent main anthropic:default

OAuth vs API key: क्या अंतर है?

Mayros दोनों support करता है:

  • OAuth अक्सर subscription access leverage करता है (जहां applicable)।
  • API keys pay-per-token billing उपयोग करती हैं।

Wizard explicitly Anthropic setup-token और OpenAI Codex OAuth support करता है और आपके लिए API keys store कर सकता है।

Gateway: ports, "already running", और remote mode

Gateway कौन सा port उपयोग करता है?

gateway.port WebSocket + HTTP (Control UI, hooks, etc.) के लिए single multiplexed port control करता है।

Precedence:

--port > MAYROS_GATEWAY_PORT > gateway.port > default 18789

mayros gateway status क्यों Runtime: running लेकिन RPC probe: failed दिखाता है?

क्योंकि "running" supervisor (launchd/systemd/schtasks) का view है। RPC probe CLI वास्तव में gateway WebSocket से connect करके status call करता है।

mayros gateway status उपयोग करें और इन lines पर trust करें:

  • Probe target: (probe ने वास्तव में उपयोग किया URL)
  • Listening: (port पर वास्तव में क्या bound है)
  • Last gateway error: (process alive लेकिन port listen नहीं कर रहा होने पर common root cause)

mayros gateway status Config (cli) और Config (service) अलग क्यों दिखाता है?

एक config file edit कर रहे हैं जबकि service दूसरी चला रही है (अक्सर --profile / MAYROS_STATE_DIR mismatch)।

Fix:

bash
mayros gateway install --force

इसे उसी --profile / environment से चलाएं जो service के लिए चाहिए।

"another gateway instance is already listening" का क्या मतलब है?

Mayros startup पर WebSocket listener immediately bind करके runtime lock enforce करता है (default ws://127.0.0.1:18789)। Bind EADDRINUSE से fail हो तो GatewayLockError throw करता है indicating दूसरी instance already listening है।

Fix: दूसरी instance stop करें, port free करें, या mayros gateway --port <port> से चलाएं।

Mayros को remote mode में कैसे चलाएं (client कहीं और Gateway से connect करे)?

gateway.mode: "remote" set करें और remote WebSocket URL पर point करें, optionally token/password के साथ:

json5
{
  gateway: {
    mode: "remote",
    remote: {
      url: "ws://gateway.tailnet:18789",
      token: "your-token",
      password: "your-password",
    },
  },
}

Notes:

  • mayros gateway तभी start होता है जब gateway.mode local हो (या override flag pass करें)।
  • macOS app config file watch करता है और ये values बदलने पर live modes switch करता है।

Control UI "unauthorized" कहता है (या reconnecting रहता है)। अब क्या?

Gateway auth enabled (gateway.auth.*) के साथ चल रहा है, लेकिन UI matching token/password नहीं भेज रहा।

Facts (code से):

  • Control UI token browser localStorage key mayros.control.settings.v1 में store करता है।

Fix:

  • सबसे तेज़: mayros dashboard (dashboard URL print + copy करता है, खोलने का प्रयास करता है; headless हो तो SSH hint दिखाता है)।
  • Token नहीं है अभी तक: mayros doctor --generate-gateway-token।
  • Remote है तो पहले tunnel: ssh -N -L 18789:127.0.0.1:18789 user@host फिर http://127.0.0.1:18789/ खोलें।
  • Gateway host पर gateway.auth.token (या MAYROS_GATEWAY_TOKEN) set करें।
  • Control UI settings में same token paste करें।
  • अभी भी stuck? mayros status --all चलाएं और Troubleshooting follow करें। Auth details के लिए Dashboard देखें।

gateway.bind: "tailnet" set किया लेकिन bind नहीं हो रहा / कुछ listen नहीं हो रहा

tailnet bind network interfaces से Tailscale IP (100.64.0.0/10) pick करता है। Machine Tailscale पर नहीं (या interface down) तो bind करने के लिए कुछ नहीं।

Fix:

  • उस host पर Tailscale start करें (ताकि 100.x address हो), या
  • gateway.bind: "loopback" / "lan" पर switch करें।

Note: tailnet explicit है। auto loopback prefer करता है; tailnet-only bind चाहिए तो gateway.bind: "tailnet" उपयोग करें।

क्या एक host पर multiple Gateways चला सकता हूं?

आमतौर पर नहीं - एक Gateway multiple messaging channels और agents चला सकता है। Multiple Gateways सिर्फ redundancy (उदा: rescue bot) या hard isolation चाहिए तब उपयोग करें।

हां, लेकिन isolate करना होगा:

  • MAYROS_CONFIG_PATH (per-instance config)
  • MAYROS_STATE_DIR (per-instance state)
  • agents.defaults.workspace (workspace isolation)
  • gateway.port (unique ports)

Quick setup (अनुशंसित):

  • प्रति instance mayros --profile <name> … उपयोग करें (auto-creates ~/.mayros-<name>)।
  • प्रत्येक profile config में unique gateway.port set करें (या manual runs के लिए --port pass करें)।
  • Per-profile service install करें: mayros --profile <name> gateway install।

Profiles service names भी suffix करते हैं (bot.molt.<profile>; legacy com.mayros.*, mayros-gateway-<profile>.service, Mayros Gateway (<profile>))। Full guide: Multiple gateways।

"invalid handshake" / code 1008 का क्या मतलब है?

Gateway WebSocket server है, और पहला message connect frame होने की उम्मीद है। कुछ और receive होने पर code 1008 (policy violation) से connection close करता है।

Common कारण:

  • Browser में HTTP URL खोला (http://...) WS client की बजाय।
  • गलत port या path उपयोग किया।
  • Proxy या tunnel ने auth headers strip किए या non-Gateway request भेजा।

Quick fixes:

  1. WS URL उपयोग करें: ws://<host>:18789 (या HTTPS हो तो wss://...)।
  2. Normal browser tab में WS port न खोलें।
  3. Auth on है तो connect frame में token/password शामिल करें।

CLI या TUI उपयोग कर रहे हैं तो URL ऐसा दिखना चाहिए:

mayros tui --url ws://<host>:18789 --token <token>

Protocol details: Gateway protocol।

Logging और debugging

logs कहां हैं?

File logs (structured):

/tmp/mayros/mayros-YYYY-MM-DD.log

logging.file से stable path set कर सकते हैं। File log level logging.level से controlled है। Console verbosity --verbose और logging.consoleLevel से controlled है।

सबसे तेज़ log tail:

bash
mayros logs --follow

Service/supervisor logs (gateway launchd/systemd से चलता है):

  • macOS: $MAYROS_STATE_DIR/logs/gateway.log और gateway.err.log (default: ~/.mayros/logs/...; profiles ~/.mayros-<profile>/logs/... उपयोग करते हैं)
  • Linux: journalctl --user -u mayros-gateway[-<profile>].service -n 200 --no-pager
  • Windows: schtasks /Query /TN "Mayros Gateway (<profile>)" /V /FO LIST

देखें Troubleshooting अधिक के लिए।

Gateway service कैसे start/stop/restart करें?

Gateway helpers उपयोग करें:

bash
mayros gateway status
mayros gateway restart

Gateway manually चलाते हैं तो mayros gateway --force port reclaim कर सकता है। देखें Gateway।

Windows पर terminal बंद कर दिया - Mayros कैसे restart करें?

दो Windows install modes हैं:

1) WSL2 (अनुशंसित): Gateway Linux के अंदर चलता है।

PowerShell खोलें, WSL enter करें, फिर restart:

powershell
wsl
mayros gateway status
mayros gateway restart

Service install नहीं किया तो foreground में start करें:

bash
mayros gateway run

2) Native Windows (अनुशंसित नहीं): Gateway directly Windows में चलता है।

PowerShell खोलें और चलाएं:

powershell
mayros gateway status
mayros gateway restart

Manually चलाते हैं (कोई service नहीं) तो:

powershell
mayros gateway run

Docs: Windows (WSL2), Gateway service runbook।

Gateway चल रहा है लेकिन replies नहीं आ रहे। क्या चेक करें?

Quick health sweep से शुरू करें:

bash
mayros status
mayros models status
mayros channels status
mayros logs --follow

Common कारण:

  • Gateway host पर model auth load नहीं (check models status)।
  • Channel pairing/allowlist replies block कर रहा (channel config + logs चेक करें)।
  • WebChat/Dashboard सही token बिना खुला है।

Remote हैं तो tunnel/Tailscale connection up और Gateway WebSocket reachable confirm करें।

Docs: Channels, Troubleshooting, Remote access।

"Disconnected from gateway: no reason" - अब क्या?

आमतौर पर UI ने WebSocket connection खो दिया। चेक करें:

  1. Gateway चल रहा है? mayros gateway status
  2. Gateway healthy है? mayros status
  3. UI में सही token है? mayros dashboard
  4. Remote हैं तो tunnel/Tailscale link up है?

फिर logs tail करें:

bash
mayros logs --follow

Docs: Dashboard, Remote access, Troubleshooting।

Telegram setMyCommands network errors से fail हो रहा है। क्या चेक करें?

Logs और channel status से शुरू करें:

bash
mayros channels status
mayros channels logs --channel telegram

VPS पर हैं या proxy के पीछे तो outbound HTTPS allowed और DNS work कर रहा confirm करें। Gateway remote है तो Gateway host पर logs देख रहे हैं सुनिश्चित करें।

Docs: Telegram, Channel troubleshooting।

TUI में कोई output नहीं दिख रहा। क्या चेक करें?

पहले Gateway reachable है और agent चल सकता है confirm करें:

bash
mayros status
mayros models status
mayros logs --follow

TUI में current state देखने के लिए /status उपयोग करें। Chat channel में replies expect करते हैं तो delivery enabled सुनिश्चित करें (/deliver on)।

Docs: TUI, Slash commands।

Gateway को पूरी तरह stop फिर start कैसे करें?

Service install किया है तो:

bash
mayros gateway stop
mayros gateway start

यह supervised service (macOS पर launchd, Linux पर systemd) stop/start करता है। Gateway background daemon के रूप में चलता है तब उपयोग करें।

Foreground में चला रहे हैं तो Ctrl-C से stop करें, फिर:

bash
mayros gateway run

Docs: Gateway service runbook।

ELI5: mayros gateway restart vs mayros gateway

  • mayros gateway restart: background service (launchd/systemd) restart करता है।
  • mayros gateway: इस terminal session के लिए gateway foreground में चलाता है।

Service install किया है तो gateway commands उपयोग करें। One-off, foreground run चाहिए तो mayros gateway उपयोग करें।

कुछ fail होने पर अधिक details पाने का सबसे तेज़ तरीका?

ज़्यादा console detail के लिए Gateway --verbose से start करें। फिर channel auth, model routing, और RPC errors के लिए log file inspect करें।

Media और attachments

skill ने image/PDF generate किया, लेकिन कुछ send नहीं हुआ

Agent से outbound attachments में अपनी line पर MEDIA:<path-or-url> line शामिल होनी चाहिए। देखें Mayros assistant setup और Agent send।

CLI sending:

bash
mayros message send --target +15555550123 --message "Here you go" --media /path/to/file.png

यह भी चेक करें:

  • Target channel outbound media support करता है और allowlists block नहीं कर रहे।
  • File provider की size limits में है (images max 2048px पर resize होती हैं)।

देखें Images।

Security और access control

क्या Mayros को inbound DMs के लिए expose करना safe है?

Inbound DMs को untrusted input treat करें। Defaults risk कम करने के लिए designed हैं:

  • DM-capable channels पर default behavior pairing है:
    • Unknown senders को pairing code मिलता है; bot उनका message process नहीं करता।
    • Approve करें: mayros pairing approve <channel> <code>
    • Pending requests प्रति channel 3 पर capped; code नहीं आया तो mayros pairing list <channel> चेक करें।
  • DMs publicly खोलने के लिए explicit opt-in चाहिए (dmPolicy: "open" और allowlist "*")।

Risky DM policies surface करने के लिए mayros doctor चलाएं।

क्या prompt injection सिर्फ public bots के लिए चिंता है?

नहीं। Prompt injection untrusted content के बारे में है, सिर्फ कौन DM कर सकता है नहीं। Assistant external content (web search/fetch, browser pages, emails, docs, attachments, pasted logs) पढ़ता है तो उस content में model hijack करने वाली instructions हो सकती हैं। यह तब भी हो सकता है जब आप एकमात्र sender हों।

सबसे बड़ा risk तब है जब tools enabled हों: model trick होकर context exfiltrate या आपकी तरफ से tools call कर सकता है। Blast radius कम करें:

  • Untrusted content summarize करने के लिए read-only या tool-disabled "reader" agent उपयोग करें
  • Tool-enabled agents के लिए web_search / web_fetch / browser off रखें
  • Sandboxing और strict tool allowlists

Details: Security।

क्या bot का अपना email GitHub account या phone number होना चाहिए?

हां, अधिकांश setups के लिए। Bot को separate accounts और phone numbers से isolate करने से कुछ गलत होने पर blast radius कम होता है। Credentials rotate या access revoke करना personal accounts impact किए बिना आसान भी होता है।

छोटा शुरू करें। सिर्फ वही tools और accounts access दें जो वास्तव में चाहिए, और बाद में ज़रूरत पड़ने पर expand करें।

Docs: Security, Pairing।

क्या इसे अपने text messages पर autonomy दे सकता हूं और क्या यह safe है?

हम personal messages पर full autonomy recommend नहीं करते। सबसे safe pattern:

  • DMs pairing mode या tight allowlist में रखें।
  • इसकी तरफ से message करवाना चाहते हैं तो separate number या account उपयोग करें।
  • Draft करवाएं, फिर भेजने से पहले approve करें।

Experiment करना चाहते हैं तो dedicated account पर करें और isolated रखें। देखें Security।

क्या personal assistant tasks के लिए सस्ते models उपयोग कर सकता हूं?

हां, अगर agent chat-only है और input trusted है। छोटे tiers instruction hijacking के लिए ज़्यादा susceptible हैं, इसलिए tool-enabled agents या untrusted content पढ़ने पर avoid करें। छोटा model उपयोग करना ही है तो tools lock down करें और sandbox में चलाएं। देखें Security।

Telegram में /start चलाया लेकिन pairing code नहीं मिला

Pairing codes तभी भेजे जाते हैं जब unknown sender bot को message करे और dmPolicy: "pairing" enabled हो। /start अकेला code generate नहीं करता।

Pending requests चेक करें:

bash
mayros pairing list telegram

Immediate access चाहिए तो sender id allowlist करें या उस account के लिए dmPolicy: "open" set करें।

WhatsApp: क्या यह मेरे contacts को message करेगा? pairing कैसे काम करती है?

नहीं। Default WhatsApp DM policy pairing है। Unknown senders को सिर्फ pairing code मिलता है और उनका message process नहीं होता। Mayros सिर्फ उन chats को reply करता है जो receive करता है या explicit sends जो आप trigger करें।

Pairing approve करें:

bash
mayros pairing approve whatsapp <code>

Pending requests list करें:

bash
mayros pairing list whatsapp

Wizard phone number prompt: आपका allowlist/owner set करने के लिए उपयोग होता है ताकि आपके DMs permitted हों। Auto-sending के लिए उपयोग नहीं होता। Personal WhatsApp number पर चलाते हैं तो वह number उपयोग करें और channels.whatsapp.selfChatMode enable करें।

Chat commands, tasks abort करना, और "यह रुकेगा नहीं"

internal system messages को chat में दिखने से कैसे रोकें?

अधिकांश internal या tool messages तभी दिखते हैं जब उस session के लिए verbose या reasoning enabled है।

जहां दिख रहा उस chat में fix:

/verbose off
/reasoning off

अभी भी noisy है तो Control UI में session settings चेक करें और verbose inherit पर set करें। यह भी confirm करें कि config में verboseDefault on set bot profile उपयोग नहीं कर रहे।

Docs: Thinking and verbose, Security।

running task को कैसे stop/cancel करें?

Standalone message (बिना slash) के रूप में इनमें से कोई भी भेजें:

stop
abort
esc
wait
exit
interrupt

ये abort triggers हैं (slash commands नहीं)।

Background processes (exec tool से) के लिए agent से चलवा सकते हैं:

process action:kill sessionId:XXX

Slash commands overview: देखें Slash commands।

अधिकांश commands / से शुरू होने वाले standalone message के रूप में भेजने होते हैं, लेकिन कुछ shortcuts (जैसे /status) allowlisted senders के लिए inline भी काम करते हैं।

Telegram से Discord message कैसे भेजें? ("Cross-context messaging denied")

Mayros default रूप से cross-provider messaging block करता है। Tool call Telegram से bound है तो Discord को नहीं भेजेगा जब तक explicitly allow न करें।

Agent के लिए cross-provider messaging enable करें:

json5
{
  agents: {
    defaults: {
      tools: {
        message: {
          crossContext: {
            allowAcrossProviders: true,
            marker: { enabled: true, prefix: "[from {channel}] " },
          },
        },
      },
    },
  },
}

Config edit करने के बाद gateway restart करें। सिर्फ single agent के लिए चाहिए तो agents.list[].tools.message में set करें।

bot rapid-fire messages को "ignore" क्यों करता है?

Queue mode control करता है नए messages in-flight run के साथ कैसे interact करें। Modes बदलने के लिए /queue उपयोग करें:

  • steer - नए messages current task redirect करते हैं
  • followup - messages एक-एक करके run करते हैं
  • collect - messages batch करता है और एक बार reply (default)
  • steer-backlog - अभी steer, फिर backlog process
  • interrupt - current run abort और fresh start

Followup modes के लिए debounce:2s cap:25 drop:summarize जैसे options जोड़ सकते हैं।

Screenshot/chat log से exact question का जवाब

Q: "API key के साथ Anthropic का default model क्या है?"

A: Mayros में credentials और model selection अलग हैं। ANTHROPIC_API_KEY set करना (या auth profiles में Anthropic API key store करना) authentication enable करता है, लेकिन actual default model वह है जो agents.defaults.model.primary में configure करें (उदाहरण, anthropic/claude-sonnet-4-5 या anthropic/claude-opus-4-6)। No credentials found for profile "anthropic:default" दिखता है तो Gateway running agent के expected auth-profiles.json में Anthropic credentials नहीं ढूंढ पाया।

अभी भी stuck? Discord में पूछें या GitHub discussion खोलें।