DeepCerebra Coder ഒരു ഏജന്റിക് കോഡിംഗ് അസിസ്റ്റന്റാണ്. ഒരു സാധാരണ ഓട്ടോകംപ്ലീറ്റ് കോപൈലറ്റിൽ നിന്ന് വ്യത്യസ്തമായി, ഇത് നിങ്ങളുടെ മുഴുവൻ പ്രോജക്റ്റിലുടനീളം ആസൂത്രണം ചെയ്യുകയും, എഴുതുകയും, റീഫാക്ടർ ചെയ്യുകയും, കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുകയും, ടൂളുകൾ വിളിക്കുകയും, ആവർത്തിക്കുകയും ചെയ്യുന്നു — നിങ്ങൾ നിർദ്ദേശിക്കുന്ന മാറ്റങ്ങൾ അവലോകനം ചെയ്യുകയും അംഗീകരിക്കുകയും ചെയ്തുകൊണ്ട്.
| പതിപ്പ് | ഏറ്റവും മികച്ചത് | ഫയൽ ആക്സസ് |
|---|---|---|
| വെബ് ആപ്പ് | ഇൻസ്റ്റാൾ ചെയ്യാതെ, ഏത് മെഷീനിൽ നിന്നും പ്രവർത്തിക്കുക | രഹസ്യാത്മക ഇൻ-ബ്രൗസർ സ്റ്റോറേജ് (കൂടാതെ Git റിപ്പോകളും) |
| ഡെസ്ക്ടോപ്പ് (Windows / Linux / macOS) | ലോക്കൽ-ഫസ്റ്റ് ഡെവലപ്മെന്റ്, ലോക്കൽ മോഡലുകൾ | നേരിട്ടുള്ള ലോക്കൽ ഫയൽ സിസ്റ്റം |
| CLI & API | സ്ക്രിപ്റ്റിംഗ്, CI/CD, ഓട്ടോമേഷൻ | ലോക്കൽ ഫയലുകൾ / പ്രോഗ്രാമാറ്റിക് |
ഈ ഗൈഡ് deepcerebra.ai-ലെ വെബ് ആപ്പിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു; ഡെസ്ക്ടോപ്പ് ആപ്പ് അതേ പാനലുകളും വർക്ക്ഫ്ലോകളും പ്രതിഫലിപ്പിക്കുന്നു.
ഒരു നിലവിലെ പതിപ്പ് ഉപയോഗിക്കുക Chrome, Edge, അല്ലെങ്കിൽ Brave പൂർണ്ണമായ അനുഭവം ലഭിക്കുന്നതിന് — ഒരു പ്രാദേശിക ഫോൾഡർ Chromium File System Access API-യെ ആശ്രയിച്ചിരിക്കുന്നു. Firefox-ഉം Safari-യും ചാറ്റിനും Git-പിന്തുണയുള്ള പ്രോജക്റ്റുകൾക്കും പ്രവർത്തിക്കും, പക്ഷേ ഒരു പ്രാദേശിക ഫോൾഡർ നേരിട്ട് തുറക്കാൻ കഴിയില്ല.
/register?plan=basic (അല്ലെങ്കിൽ pro / ultimate) സന്ദർശിച്ച് ഒരു പ്ലാൻ തിരഞ്ഞെടുക്കാം, അല്ലെങ്കിൽ ഇപ്പോൾ ആരംഭിച്ച് പിന്നീട് Billing-ൽ ഒരു പ്ലാൻ തിരഞ്ഞെടുക്കാം.സൈൻ ഇൻ ചെയ്ത ശേഷം നിങ്ങൾ വർക്ക്ബെഞ്ചിൽ എത്തുന്നു, അത് എല്ലാ പാനുകളും ഒരു സ്ക്രീനിൽ കാണിക്കുന്നു:
ലേഔട്ട് റീബാലൻസ് ചെയ്യാൻ എഡിറ്ററിനും ചാറ്റിനും ഇടയിലുള്ള സ്പ്ലിറ്റർ വലിക്കുക, ടെർമിനലിന്റെ വലുപ്പം മാറ്റാൻ തിരശ്ചീനമായ സ്പ്ലിറ്റർ വലിക്കുക. ഇടത് സൈഡ്ബാർ വർക്ക്സ്പെയ്സ്, എക്സ്റ്റൻഷനുകൾ, API കീകൾ, ബില്ലിംഗ്, ഫീഡ്ബാക്ക് എന്നിവയിലേക്കും നാവിഗേറ്റ് ചെയ്യുന്നു.
repo സ്കോപ്പ് (ക്ലാസിക്) അല്ലെങ്കിൽ Contents + Pull requests ഉള്ള ഒരു ഫൈൻ-ഗ്രെയിൻഡ് ടോക്കൺ ഉപയോഗിക്കുക; GitLab-ന് api സ്കോപ്പ് ഉപയോഗിക്കുക. നിങ്ങളുടെ ടോക്കൺ സെർവറിൽ സൂക്ഷിക്കുന്നു — ഫയൽ ഉള്ളടക്കങ്ങൾ മാത്രമേ ബ്രൗസറിലേക്ക് വലിച്ചെടുക്കുകയുള്ളൂ.owner/name ആയി റിപ്പോസിറ്ററി ടൈപ്പ് ചെയ്യുക (നിങ്ങളുടേത് കണ്ടെത്താൻ ലിസ്റ്റ് ഫിൽട്ടർ ചെയ്യുക), തുടർന്ന് ഒരു ബ്രാഞ്ച് തിരഞ്ഞെടുക്കുക.dcc/my-feature) ടിക്ക് ചെയ്യുക.ചാറ്റ് ചരിത്രം തുറന്ന പ്രോജക്റ്റുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു. ഫോൾഡറുകൾ മാറ്റുന്നത് ഒരു പുതിയ സെഷൻ സ്വയമേവ ആരംഭിക്കുകയും ആ ഫോൾഡറിന്റെ മുൻ സെഷനുകൾ ലോഡ് ചെയ്യുകയും, ഏറ്റവും പുതിയത് വീണ്ടും തുറക്കുന്നതിലൂടെ നിങ്ങൾക്ക് നിർത്തിയിടത്തുനിന്ന് തുടരാം.
DeepCerebra ആന്തരികമായി ഉപയോഗിക്കുന്ന ഫോൾഡറുകൾ — .deepcerebra, .sessions — ട്രീയിൽ ദൃശ്യമാകും, പക്ഷേ നിങ്ങളുടെ സോഴ്സിനെ അലങ്കോലപ്പെടുത്താതിരിക്കാൻ സ്ഥിരസ്ഥിതിയായി ചുരുക്കിയിരിക്കുന്നു.
നിങ്ങൾക്ക് ആവശ്യമുള്ളത് ലളിതമായ ഭാഷയിൽ വിവരിക്കുക — ഒരു ചോദ്യം ചോദിക്കുക, ഒരു ഫീച്ചർ അഭ്യർത്ഥിക്കുക, അല്ലെങ്കിൽ ഒരു ബഗ് ചൂണ്ടിക്കാണിക്കുക. മികച്ച ഫലം ലഭിക്കുന്നതിന് ഫയലുകൾ, ഫ്രെയിംവർക്കുകൾ, നിയന്ത്രണങ്ങൾ എന്നിവയെക്കുറിച്ച് വ്യക്തമായിരിക്കുക. പ്രസക്തമായ ഫയലുകൾ പ്രോംപ്റ്റിലേക്ക് വലിച്ചിട്ട് അറ്റാച്ചുചെയ്യുക.
പ്രതികരണങ്ങൾ കഴ്സർ പോലെയാണ് ക്രമീകരിച്ചിരിക്കുന്നത്: ഏജന്റിന്റെ യുക്തി ഡെലിവറബിളിൽ നിന്ന് വേർതിരിച്ചിരിക്കുന്നു. ഓരോ പ്രതികരണ ബ്ലോക്കിനും അതിന്റെ മുകളിൽ വലത് കോണിൽ ഒരു കോപ്പി ഐക്കൺ ഉണ്ട്, അതിനാൽ നിങ്ങൾക്ക് പൂർത്തിയാക്കിയ ഒരു റിപ്പോർട്ട്, ഡോക്യുമെന്റ്, അല്ലെങ്കിൽ പ്രവർത്തിപ്പിക്കാൻ ഉദ്ദേശിക്കുന്ന ഒരു കമാൻഡ് എന്നിവ പകർത്താൻ കഴിയും.
lxml instead of html.parser").@deepcerebra ഉപയോഗിച്ച് ചാറ്റിൽ ഏജന്റിനെ വിളിക്കുന്നു, കൂടാതെ [deep] പോലുള്ള പ്രിഫിക്സുകൾ കൂടുതൽ ആഴത്തിലുള്ള യുക്തി ആവശ്യപ്പെടുന്നു.പ്രോംപ്റ്റിന് അടുത്തുള്ള മോഡ് സെലക്ടറിൽ നിന്ന് ഒരു മോഡ് തിരഞ്ഞെടുക്കുക. ഓരോന്നും ഏജന്റ് എത്രത്തോളം ആസൂത്രണം ചെയ്യുന്നു, എത്രത്തോളം സ്വതന്ത്രമായി എഡിറ്റ് ചെയ്യുന്നു എന്ന് ക്രമീകരിക്കുന്നു:
| മോഡ് | അത് എന്തുചെയ്യുന്നു | എപ്പോൾ ഉപയോഗിക്കണം… |
|---|---|---|
| ഏജന്റ് | നിങ്ങളുടെ പ്രോജക്റ്റിലുടനീളം സ്വയംഭരണപരമായി ആസൂത്രണം ചെയ്യുകയും എഡിറ്റ് ചെയ്യുകയും ചെയ്യുന്നു | അസിസ്റ്റന്റ് ഒരു മാറ്റം പൂർണ്ണമായി നടപ്പിലാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു |
| ചോദിക്കുക | എഡിറ്റ് ചെയ്യാതെ നിങ്ങളുടെ കോഡിനെക്കുറിച്ചുള്ള ചോദ്യങ്ങൾക്ക് ഉത്തരം നൽകുന്നു | കോഡ്ബേസ് മനസ്സിലാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു |
| പ്ലാൻ | ഏതെങ്കിലും എഡിറ്റിംഗിന് മുമ്പ് ഒരു സമീപനം തയ്യാറാക്കുന്നു | ടാസ്ക് വലുതാണ് അല്ലെങ്കിൽ ആദ്യം പരിഹരിക്കേണ്ട വിട്ടുവീഴ്ചകളുണ്ട് |
| തിരുത്തുക | നിലവിലെ സന്ദർഭത്തിൽ ശ്രദ്ധ കേന്ദ്രീകരിച്ചുള്ള എഡിറ്റുകൾ നടത്തുന്നു | നിങ്ങൾക്ക് ഒരു ചെറിയ, ലക്ഷ്യമിട്ട മാറ്റം വേണം |
ഏജന്റ് ഫയൽ മാറ്റങ്ങൾ നിർദ്ദേശിക്കുമ്പോൾ, ഒരു നിർദ്ദേശിച്ച മാറ്റങ്ങൾ എന്ന പാനൽ ചാറ്റ് ഇൻപുട്ടിന് മുകളിൽ ദൃശ്യമാകും, ഓരോ മാറ്റം വരുത്തിയ ഫയലും ചേർത്തവയുടെ (+) നീക്കം ചെയ്തവയുടെയും (−) ലൈൻ എണ്ണങ്ങളോടൊപ്പം ലിസ്റ്റ് ചെയ്യുന്നു.
applied എന്ന് അടയാളപ്പെടുത്തുന്നു (ഒരു യഥാർത്ഥ ഫോൾഡറിലേക്ക് എഴുതുമ്പോൾ · disk എന്നും).ബിൽഡുകൾ, ടെസ്റ്റുകൾ, സ്ക്രിപ്റ്റുകൾ എന്നിവ പ്രവർത്തിപ്പിക്കുന്നതിന് എഡിറ്ററിന് താഴെയുള്ള ടെർമിനൽ ടോഗിൾ ചെയ്യുക. നിങ്ങളുടെ അനുമതിയോടെ, ഏജൻ്റിന് അതിൻ്റെ പ്രവർത്തനം പരിശോധിക്കുന്നതിനായി കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കാനും അവയുടെ ഔട്ട്പുട്ട് വായിക്കാനും കഴിയും; ദീർഘനേരം പ്രവർത്തിക്കുന്ന കമാൻഡുകൾ ഔട്ട്പുട്ട് സ്ട്രീം ചെയ്യുന്നതിനാൽ നിങ്ങൾക്ക് പുരോഗതി നിരീക്ഷിക്കാൻ സാധിക്കും. ആവശ്യമില്ലാത്തപ്പോൾ ടെർമിനൽ അതിൻ്റെ ഹെഡറിൽ നിന്ന് ക്ലോസ് ചെയ്യുക.
വലിയ ലക്ഷ്യങ്ങൾക്കായി, പ്ലാൻ മോഡ് ഉപയോഗിക്കുക (അല്ലെങ്കിൽ ഏജന്റിനോട് ആദ്യം പ്ലാൻ ചെയ്യാൻ ആവശ്യപ്പെടുക). പ്ലാനർ നിങ്ങളുടെ പ്രോജക്റ്റ് സ്കാൻ ചെയ്യുന്നു, ലക്ഷ്യത്തെ ഡിപൻഡൻസി-അവബോധമുള്ള ടാസ്ക്കുകളായി വിഭജിക്കുന്നു, ഓരോന്നിനെയും ശരിയായ സ്പെഷ്യലിസ്റ്റിന് (ആർക്കിടെക്റ്റ്, കോഡർ, ടെസ്റ്റർ, ഡോക്സ്) നൽകുന്നു.
പ്രോംപ്റ്റിന് അടുത്തുള്ള മോഡൽ പിക്കർ തുറക്കുക. ഓപ്ഷനുകൾ ഇങ്ങനെ തരംതിരിച്ചിരിക്കുന്നു:
ഓട്ടോയിൽ, DeepCerebra ടയേർഡ്, അഡാപ്റ്റീവ് റൂട്ടിംഗ് ഉപയോഗിക്കുന്നു: ലളിതമായ ടാസ്ക്കുകൾ വേഗതയേറിയതും സാമ്പത്തികവുമായ മോഡലിലേക്ക് പോകുന്നു, അതേസമയം സങ്കീർണ്ണമായ അല്ലെങ്കിൽ പ്ലാനിംഗ്-ഹെവി ജോലികൾ (ഉദാഹരണത്തിന്, പ്ലാൻ മോഡ്) ശക്തമായ ഒരു മോഡലിലേക്ക് റൂട്ട് ചെയ്യുന്നു. ഇത് ചെലവും ഗുണനിലവാരവും സ്വയമേവ സന്തുലിതമാക്കുന്നു, അതിനാൽ നിങ്ങൾക്ക് സ്വമേധയാ തിരഞ്ഞെടുക്കേണ്ടി വരുന്നത് വളരെ വിരളമാണ്.
അളന്ന പ്ലാറ്റ്ഫോം ഉപയോഗത്തിന് പകരം നിങ്ങളുടെ സ്വന്തം പ്രൊവൈഡർ അക്കൗണ്ട് വഴി അഭ്യർത്ഥനകൾ റൂട്ട് ചെയ്യാൻ നിങ്ങൾക്ക് കഴിയും.
ANTHROPIC_API_KEY,
GOOGLE_API_KEY, OPENAI_API_KEY).പ്ലാറ്റ്ഫോം (DeepCerebra) മോഡലുകൾക്ക് കീ ആവശ്യമില്ല. Remove ഉപയോഗിച്ച് എപ്പോൾ വേണമെങ്കിലും ഒരു കീ നീക്കം ചെയ്യുക.
DCC Bridge നിങ്ങളുടെ സ്വന്തം കമ്പ്യൂട്ടറിനെ ഒരു ചെറിയ
dcc-bridge കണക്ടർ വഴി വെബ് ആപ്പുമായി ബന്ധിപ്പിക്കുന്നു, ഇത് ഒരേ സമയം രണ്ട് കഴിവുകൾ അൺലോക്ക് ചെയ്യുന്നു:
കണക്ടർ ഒരു ആധികാരിക WebSocket വഴി പുറത്തേക്ക് ഡയൽ ചെയ്യുന്നു — ഇൻബൗണ്ട് പോർട്ടുകൾ ആവശ്യമില്ല, ഇത് NAT-നും ഫയർവാളുകൾക്കും പിന്നിൽ പ്രവർത്തിക്കുന്നു. ഇത് Windows, macOS, Linux (Python 3.10+) എന്നിവയിൽ പ്രവർത്തിക്കുന്നു.
dcc_brg_…)
പേസ്റ്റ് ചെയ്യാൻ തയ്യാറായ കണക്റ്റർ കമാൻഡും പകർത്തുക — ടോക്കൺ കൃത്യമായി ഒരു തവണ മാത്രമേ കാണിക്കൂ.pip install git+https://github.com/mohammadkhair7/DeepCerebra-connector
# then run the command copied from the pairing card, e.g.:
python -m dcc_bridge --gateway wss://deepcerebra.ai --token dcc_brg_xxxxxwss://deepcerebra.ai അല്ലെങ്കിൽ wss://deepcerebra.io) — പെയറിംഗ് കാർഡ് ശരിയായത് മുൻകൂട്ടി പൂരിപ്പിക്കുന്നു. ഈ രണ്ട് സൈറ്റുകളും പ്രത്യേക അക്കൗണ്ടുകളും ടോക്കണുകളുമുള്ള വ്യത്യസ്ത ഡിപ്ലോയ്മെന്റുകളാണ്.1234) ഒരു മോഡൽ ലോഡ് ചെയ്തുകൊണ്ട് പ്രവർത്തനക്ഷമമാക്കുക.സ്ഥിരസ്ഥിതിയായി, കമാൻഡുകൾ ഒരു പ്രത്യേക വർക്ക്സ്പേസ് ഫോൾഡറിൽ (~/DeepCerebra) ഒതുക്കിയിരിക്കുന്നു. നിങ്ങളുടെ മുൻകൂട്ടി കോൺഫിഗർ ചെയ്ത CLI-കൾ ഉപയോഗിച്ച് നിങ്ങളുടെ യഥാർത്ഥ പ്രോജക്റ്റ് ഫോൾഡറുകളിൽ പ്രവർത്തിക്കാൻ, കണക്ടർ ആരംഭിക്കുമ്പോൾ അവയ്ക്ക് വ്യക്തമായി അനുമതി നൽകുക:
# grant one or more real folders (repeatable)
python -m dcc_bridge --gateway wss://deepcerebra.ai --token dcc_brg_xxxxx --host-dir "F:\MyProjects"
# or the whole machine (prints a warning; prefer --host-dir)
python -m dcc_bridge ... --allow-any-dirതുടർന്ന് Terminal പാനൽ തുറക്കുക, Execution target പോപോവറിൽ (ലാപ്ടോപ്പ് ഐക്കൺ) ക്ലിക്ക് ചെയ്യുക, My computer തിരഞ്ഞെടുക്കുക, ഒരു വർക്കിംഗ് ഡയറക്ടറി തിരഞ്ഞെടുക്കുക. നിങ്ങൾ ടൈപ്പ് ചെയ്ത കമാൻഡുകളും ഏജന്റിന്റെ ബിൽഡ്/ടെസ്റ്റ് കമാൻഡുകളും നിങ്ങളുടെ മെഷീനിൽ പ്രവർത്തിപ്പിക്കും.
--no-exec ഒരു ഉപകരണത്തെ ഇൻഫറൻസ്-മാത്രം ആക്കുന്നു (GPU മോഡലുകൾ, കമാൻഡുകളില്ല).ഒരു Git-ബാക്കഡ് പ്രോജക്റ്റ് തുറന്നിരിക്കുമ്പോൾ, എക്സ്പ്ലോററിൽ ഒരു ബ്രാഞ്ച് ബാർ ദൃശ്യമാകും, നിങ്ങളുടെ നിലവിലെ ബ്രാഞ്ചും രണ്ട് പ്രവർത്തനങ്ങളും കാണിക്കുന്നു:
main) ഒരു പുൾ അഭ്യർത്ഥന തുറക്കുക. നിങ്ങൾ ഒരു വർക്കിംഗ് ബ്രാഞ്ചിൽ ആയിരിക്കണം, ഡിഫോൾട്ട് ബ്രാഞ്ചിൽ ആയിരിക്കരുത്.പുഷ് വെബ്ഹുക്ക് പ്രവർത്തനക്ഷമമാക്കിയിട്ടുണ്ടെങ്കിൽ, ടീം അംഗങ്ങൾ പുഷ് ചെയ്യുമ്പോൾ എക്സ്പ്ലോറർ സ്വയമേവ റീഫ്രഷ് ചെയ്യുകയും എല്ലാവരെയും സമന്വയിപ്പിക്കുകയും ചെയ്യുന്നു — DeepCerebra വഴിയുള്ള സഹകരണ ടീം ഡെവലപ്മെന്റിന്റെ അടിസ്ഥാനം.
ബാഹ്യ ടൂളുകളും ഡാറ്റയും ഉപയോഗിച്ച് ഏജന്റിനെ Model Context Protocol വഴി വികസിപ്പിക്കുക. ഒരു
സെർവറുകൾ .deepcerebra/mcp.json ഫയലിൽ കോൺഫിഗർ ചെയ്യുക, ഉദാഹരണത്തിന്:
{
"mcpServers": {
"my-tools": {
"url": "https://example.com/mcp",
"disabled": false,
"allowlist": ["search_issues", "get_pr"],
"autoApprove": ["create_issue"],
"auth": { "type": "bearer", "tokenEnv": "MY_TOKEN" }
}
}
}നിങ്ങളുടെ അഭ്യർത്ഥനയുമായി ബന്ധപ്പെട്ടതാണെങ്കിൽ പ്രവർത്തനക്ഷമമാക്കിയ MCP ടൂളുകൾ ഏജന്റിന് സ്വയമേവ ലഭ്യമാകും. ലോക്കൽ (stdio) ഉം റിമോട്ട് (http/sse) സെർവറുകളും പിന്തുണയ്ക്കുന്നു.
allowlist ലിസ്റ്റ് ചെയ്യുമ്പോൾ, ആ ടൂളുകൾക്ക് മാത്രമേ പ്രവർത്തിക്കാൻ കഴിയൂ.autoApprove-ൽ നിങ്ങൾ മുൻകൂട്ടി അംഗീകരിച്ചിട്ടില്ലെങ്കിൽ അംഗീകാരം ആവശ്യമാണ്.ഒരു സെർവർ MCP വിഭവങ്ങളോ അല്ലെങ്കിൽ പ്രോംപ്റ്റ് ടെംപ്ലേറ്റുകളോ എക്സ്പോസ് ചെയ്യുകയാണെങ്കിൽ, അവ ഉപയോഗിക്കാനുള്ള ടൂളുകൾ (mcp_list_resources, mcp_read_resource,
mcp_list_prompts, mcp_get_prompt) ഏജന്റിന് സ്വയമേവ ലഭിക്കും.
ഒരു റിമോട്ട് സെർവറിലേക്ക് ഒരു auth ബ്ലോക്ക് ചേർക്കുക. രഹസ്യങ്ങൾ ${ENV_VAR} ഇന്റർപോളേഷൻ പിന്തുണയ്ക്കുന്നു:
// Static bearer token (literal or from env)
"auth": { "type": "bearer", "token": "${GITHUB_TOKEN}" }
"auth": { "type": "bearer", "tokenEnv": "GITHUB_TOKEN" }
// Custom header (e.g. API key)
"auth": { "type": "header", "header": "x-api-key", "value": "${MY_KEY}" }
// OAuth 2.0 client-credentials
"auth": {
"type": "oauth", "grant": "client_credentials",
"tokenUrl": "https://auth.example.com/oauth/token",
"clientId": "${MCP_CLIENT_ID}", "clientSecret": "${MCP_CLIENT_SECRET}",
"scope": "mcp.read mcp.write"
}ഏജന്റ് എങ്ങനെ ചിന്തിക്കുകയും പ്രവർത്തിക്കുകയും ചെയ്യുന്നു എന്ന് നിങ്ങൾക്ക് ഒരു ഏകീകൃത, ഫയൽ അധിഷ്ഠിത കൺവെൻഷൻ —
.deepcerebra/ ഡയറക്ടറി — ഉപയോഗിച്ച് രൂപപ്പെടുത്താൻ കഴിയും, ഇത് ഡെസ്ക്ടോപ്പ് ആപ്പ്,
വെബ് ആപ്പ്, API എന്നിവയിൽ ഒരുപോലെ പ്രവർത്തിക്കുന്നു. വെബ് ആപ്പിൽ, ഇവയെല്ലാം
Agent വ്യൂവിന് കീഴിൽ കൈകാര്യം ചെയ്യുക; ഡെസ്ക്ടോപ്പിലും API വഴിയും അവ നിങ്ങളുടെ പ്രോജക്റ്റുമായി കമ്മിറ്റ് ചെയ്യുന്ന സാധാരണ ഫയലുകളാണ്.
കോൺഫിഗറേഷൻ നിരവധി സ്കോപ്പുകളിൽ നിന്ന് കണ്ടെത്തുന്നു; ഒരേ ഇനം ഒന്നിൽ കൂടുതൽ സ്ഥലങ്ങളിൽ നിലവിലുണ്ടെങ്കിൽ, ഉയർന്ന മുൻഗണനയുള്ളത് വിജയിക്കുന്നു:
team/org < global (~/.deepcerebra) < workspace (<repo>/.deepcerebra)
(ഏറ്റവും കുറഞ്ഞത്) (ഏറ്റവും ഉയർന്നത്)<repo>/.deepcerebra/…, പ്രോജക്റ്റുമായി കമ്മിറ്റ് ചെയ്തത്.~/.deepcerebra/…, പ്രോജക്റ്റുകളിലുടനീളമുള്ള നിങ്ങളുടെ വ്യക്തിഗത സ്ഥിരസ്ഥിതികൾ.നിയമങ്ങൾ സ്ഥിരമായ നിർദ്ദേശങ്ങളാണ് — കോഡിംഗ് സ്റ്റാൻഡേർഡുകൾ, ആർക്കിടെക്ചർ കൺവെൻഷനുകൾ, ഡൊമെയ്ൻ സന്ദർഭം — ഏജന്റിന്റെ സിസ്റ്റം പ്രോംപ്റ്റിലേക്ക് കുത്തിവയ്ക്കുന്നു. അവ .deepcerebra/steering/ എന്നതിന് കീഴിലുള്ളMarkdown ഫയലുകളായി നിലനിൽക്കുന്നു, കൂടാതെ എപ്പോഴും ഓൺ ആയിരിക്കുന്നAGENTS.md സ്റ്റാൻഡേർഡും. ഒരു റൂൾ എപ്പോൾ ലോഡ് ചെയ്യണമെന്ന് ഫ്രണ്ട്മാറ്റർ നിയന്ത്രിക്കുന്നു:
---
inclusion: fileMatch # always | fileMatch | auto | manual
globs: "src/**/*.ts" # or fileMatchPattern
name: api-design
description: REST conventions
---
# API design
- Use REST resource nouns, plural.always — ഓരോ ഊഴത്തിലും (സ്ഥിരസ്ഥിതി).fileMatch — ഒരു ഇൻ-കോൺടെക്സ്റ്റ് ഫയൽ globs-മായി പൊരുത്തപ്പെടുമ്പോൾ മാത്രം.auto — നിങ്ങളുടെ അഭ്യർത്ഥന നിയമത്തിന്റെ name/description-മായി പൊരുത്തപ്പെടുമ്പോൾ.manual — നിങ്ങൾ അതിനെ #name അല്ലെങ്കിൽ /name എന്ന് പരാമർശിക്കുമ്പോൾ മാത്രം.ഒരു റൂട്ട് AGENTS.md റിപ്പോ-വൈഡ് ആയി ബാധകമാണ്; ഒരു നെസ്റ്റഡ് AGENTS.md (ഉദാ.
services/api/AGENTS.md) ആ ഫോൾഡറിന് കീഴിലുള്ള ഫയലുകൾക്ക് മാത്രം ബാധകമാണ്. വെബ് ആപ്പിൽ,
Agent → Steering വ്യൂ ഓരോ റൂളിനും ഒരു Scope പിക്കർ
(Global / Project / Team) നൽകുന്നു.
കഴിവുകൾ ഏജന്റ് ആവശ്യാനുസരണം ലോഡ് ചെയ്യുന്ന പുനരുപയോഗിക്കാവുന്ന പ്ലേബുക്കുകളാണ്. ഓരോ കഴിവും .deepcerebra/skills/ എന്നതിന് കീഴിൽ SKILL.md എന്ന ഫയലുള്ള ഒരു ഫോൾഡറാണ്:
---
name: deploy-release
description: How to cut and publish a versioned release.
disable-model-invocation: false # true => manual-only (/skill)
---
# Deploy a release
1. Bump the version, build, and test.
2. Tag and publish.ഏജൻ്റ് ഒരു ലഘുവായ കാറ്റലോഗ് (പേര് + വിവരണം) കാണുകയും, പ്രസക്തമാകുമ്പോൾ load_skill ടൂൾ ഉപയോഗിച്ച് അതിൻ്റെ പൂർണ്ണരൂപം എടുക്കുകയും ചെയ്യുന്നു. നിങ്ങൾക്ക് /skill <name> ഉപയോഗിച്ച് ഒരെണ്ണം വ്യക്തമായി ഇൻവോക്ക് ചെയ്യാനും കഴിയും. ഒരു സ്കിൽ മാനുവൽ മാത്രമാക്കാൻ disable-model-invocation: true എന്ന് സെറ്റ് ചെയ്യുക.
ഹുക്കുകൾ ലൈഫ് സൈക്കിൾ ഇവന്റുകളിൽ ഓട്ടോമേഷൻ പ്രവർത്തിപ്പിക്കുന്നു. അവയെ .deepcerebra/hooks/*.hook.json ആയി നിർവചിക്കുക:
{
"title": "Format on save",
"event": "fileSave",
"filePattern": ["**/*.ts"],
"action": { "type": "shell", "command": "npm run lint:fix -- $FILE" },
"enabled": true
}ഇവന്റുകളിൽ promptSubmit, preToolUse, postToolUse,
fileCreate, fileSave, fileDelete, preTask,
postTask, sessionStart, preCompact, agentStop എന്നിവ ഉൾപ്പെടുന്നു
(Cursor/Claude സ്പെല്ലിംഗുകളും സ്വീകാര്യമാണ്). ഒരു പ്രവർത്തനം ഒന്നുകിൽ shell (ഒരു കമാൻഡ് പ്രവർത്തിപ്പിക്കുക) അല്ലെങ്കിൽ
agentPrompt (ഏജന്റിനോട് ചോദിക്കുക) ആണ്. ഒരു preToolUse ഹുക്കിന് അത് തടയുന്ന ടൂൾ കോളിന്
അനുവദിക്കുക, നിഷേധിക്കുക, അല്ലെങ്കിൽ ചോദിക്കുക എന്നിവ ചെയ്യാൻ കഴിയും.
സബ്ഏജന്റുകൾ നിങ്ങൾ നിർവചിക്കുകയും ചുമതലപ്പെടുത്തുകയും ചെയ്യുന്ന സ്പെഷ്യലിസ്റ്റ് ഏജന്റുകളാണ്. ഓരോന്നും
.deepcerebra/agents/ എന്നതിന് കീഴിൽ ഫ്രണ്ട്മാറ്ററും ഒരു ബോഡിയും (അതിന്റെ സിസ്റ്റം പ്രോംപ്റ്റ്) ഉള്ള ഒരു Markdown ഫയലാണ്:
---
name: security-reviewer
description: Audits a diff for security issues; read-only.
model: gpt-5
readonly: true
tools: [read_file, grep_files, list_directory]
background: false
---
You are a meticulous security reviewer…പ്രധാന ഏജന്റ് task (തടയുന്നത്), task_async +
task_status / task_result (പശ്ചാത്തലം), അല്ലെങ്കിൽ task_parallel (ഫാൻ-ഔട്ട്) എന്നിവ ഉപയോഗിച്ച് ചുമതലപ്പെടുത്തുന്നു.
ഒരു പ്ലഗിൻ നിയമങ്ങൾ, കഴിവുകൾ, ഹുക്കുകൾ, സബ്ഏജന്റുകൾ, MCP സെർവറുകൾ എന്നിവയെല്ലാം
.deepcerebra/plugins/<name>/ എന്നതിന് കീഴിലുള്ള ഒരു ഇൻസ്റ്റാൾ ചെയ്യാവുന്ന പാക്കേജായി ബണ്ടിൽ ചെയ്യുന്നു, ഇത് ഒരു plugin.json മാനിഫെസ്റ്റ് വഴി വിവരിക്കുന്നു:
{
"name": "Acme Standards",
"version": "1.2.0",
"description": "Acme rules + skills + review agents.",
"enabled": true
}പ്ലഗിൻ ഉള്ളടക്കങ്ങൾ ഏറ്റവും കുറഞ്ഞ മുൻഗണനയിൽ ലയിപ്പിക്കുന്നു, അതിനാൽ നിങ്ങളുടെ സ്വന്തം നിയമങ്ങളും കഴിവുകളും ഒരു പ്ലഗിനിന്റേതിനെ എപ്പോഴും അസാധുവാക്കും.
"enabled": false ഉപയോഗിച്ചോ അല്ലെങ്കിൽ ഒരു .disabled മാർക്കർ ഫയൽ ഉപയോഗിച്ചോ ഒരു പ്ലഗിൻ പ്രവർത്തനരഹിതമാക്കുക.
DCC_ORG_CONFIG_DIR ഒരു പങ്കിട്ട
.deepcerebra ഡയറക്ടറിയിലേക്ക് ചൂണ്ടിക്കാണിച്ചുകൊണ്ട്, അല്ലെങ്കിൽ വെബ് ആപ്പിൽ നിയമങ്ങൾ
Team സ്കോപ്പിലേക്ക് സജ്ജീകരിച്ചുകൊണ്ട് പങ്കിട്ട സ്ഥിരസ്ഥിതികൾ പ്രസിദ്ധീകരിക്കാൻ കഴിയും.മൾട്ടി-ഏജന്റ് ഓട്ടോമേഷനു വേണ്ടിയുള്ള ഒരു വിഷ്വൽ ഡിസൈനറാണ് Workflow Studio. നിങ്ങൾ ഘട്ടങ്ങൾ — ഓരോന്നും ഒരു ഏജന്റ്, ഒരു സ്പെഷ്യലിസ്റ്റ് സ്റ്റെപ്പ്, അല്ലെങ്കിൽ ഒരു കൺട്രോൾ പ്രിമിറ്റീവ് — ഒരു ഗ്രാഫിലേക്ക് രചിക്കുകയും, അവയെ ഡിപൻഡൻസികൾ ഉപയോഗിച്ച് ബന്ധിപ്പിക്കുകയും, ഓരോ ഘട്ടത്തിലെയും തത്സമയ പുരോഗതി, ബഡ്ജറ്റുകൾ, മനുഷ്യന്റെ അംഗീകാരത്തിനുള്ള ഗേറ്റുകൾ എന്നിവയോടൊപ്പം മുഴുവൻ ഓർക്കസ്ട്രേഷനും എഞ്ചിനിൽ പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നു. വർക്ക്ഫ്ലോകൾ ഒരു പോർട്ടബിൾ YAML/JSON ഡെഫനിഷനായി സേവ് ചെയ്യപ്പെടുന്നു, ഇത് നിങ്ങൾക്ക് എക്സ്പോർട്ട് ചെയ്യാനും, ഇമ്പോർട്ട് ചെയ്യാനും, Git-ൽ പതിപ്പ് നിയന്ത്രിക്കാനും, API അല്ലെങ്കിൽ CLI-ൽ നിന്ന് പ്രവർത്തിപ്പിക്കാനും സാധിക്കും.
| സ്റ്റേജ് തരം | അത് എന്തുചെയ്യുന്നു |
|---|---|
agent | നിങ്ങൾ അറ്റാച്ചുചെയ്യുന്ന കഴിവുകളും ടൂളുകളും ഉപയോഗിച്ച് ഒരു ഏജന്റ് ഊഴം. |
spec.requirements / spec.design / spec.execute |
സ്പെക്-ഫസ്റ്റ് ഡെലിവറി: ആവശ്യകതകൾ തയ്യാറാക്കുക, രൂപകൽപ്പന ചെയ്യുക, തുടർന്ന് ടാസ്ക്കുകളായി വിഭജിച്ച് നടപ്പിലാക്കുക — ഓരോന്നും ഗേറ്റ് ചെയ്യാവുന്നതാണ്. |
documents.generate | മുൻ ഘട്ടങ്ങളിലെ ഔട്ട്പുട്ടുകളിൽ നിന്ന് ഒരു മിനുക്കിയ ഡോക്യുമെന്റ് ഉണ്ടാക്കുക. |
fan_out | നിരവധി ഉപവിഷയങ്ങളിലുടനീളം സിന്തസിസോടെയുള്ള സമാന്തര വിശാലമായ ഗവേഷണം. |
map / loop / switch |
കൺട്രോൾ പ്രിമിറ്റീവുകൾ: ഓരോ ഇനത്തിനും ഒരു ബോഡി പ്രവർത്തിപ്പിക്കുക, ഒരു കണ്ടീഷൻ വരെ ആവർത്തിക്കുക, അല്ലെങ്കിൽ കേസുകളിലുടനീളം ബ്രാഞ്ച് ചെയ്യുക. |
verify / browser_verify |
സാൻഡ്ബോക്സിൽ ടെസ്റ്റുകളോ കമാൻഡുകളോ പ്രവർത്തിപ്പിക്കുക; ബ്രൗസർ ഓട്ടോമേഷൻ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്ന ഒരു UI പരിശോധിക്കുക. |
orchestrate | ഡൈനാമിക് റൂട്ടിംഗ്: ഒരു ഓർക്കസ്ട്രേറ്റർ ഏജന്റ് അഭ്യർത്ഥന വായിക്കുകയും ഇവന്റുകളിലൂടെ ഏറ്റവും മികച്ച ഡൗൺസ്ട്രീം ഏജന്റ്(കളെ) അയയ്ക്കുകയും ചെയ്യുന്നു. |
external.agent | ഒരു രജിസ്റ്റർ ചെയ്ത മൂന്നാം കക്ഷി ഏജന്റിനെ HTTP (A2A) വഴി ഒരു നേറ്റീവ് സ്റ്റേജ് പോലെ വിളിക്കുക. |
eval | ചെക്കുകൾക്കെതിരെ (അടങ്ങിയിരിക്കുന്നു / regex / നീളം / LLM-judge) ഒരു അപ്സ്ട്രീം ഔട്ട്പുട്ട് സ്കോർ ചെയ്യുക; ഒരു പരിധിക്ക് താഴെ പരാജയപ്പെടുക. |
db.provision | ഒരു ഉടമസ്ഥതയിലുള്ള ഡാറ്റാ ലെയർ ഉണ്ടാക്കുക: ഡാറ്റാബേസിനായുള്ള docker-compose, പതിപ്പ് ചെയ്ത SQL മൈഗ്രേഷനുകൾ, സീഡ് ഡാറ്റ, .env ടെംപ്ലേറ്റ്, ഒരു Mermaid ERD; ഓപ്ഷണൽ ഓത്ത് സ്കഫോൾഡ്; SQLite-ലേക്ക് മൈഗ്രേഷനുകൾ ഉടനടി പ്രയോഗിക്കാൻ കഴിയും. |
ci.generate | lint → test → scan → build → deploy, എൻവയോൺമെന്റ് പ്രൊമോഷൻ എന്നിവയോടുകൂടിയ ഒരു റെഡി-ടു-കമ്മിറ്റ് CI/CD പൈപ്പ്ലൈൻ (GitHub Actions, GitLab CI, അല്ലെങ്കിൽ Azure Pipelines) ഉണ്ടാക്കുക. |
deploy.package | പ്രൊഡക്ഷൻ ഡിപ്ലോയ്മെന്റ് അസറ്റുകൾ സൃഷ്ടിക്കുക: മൾട്ടി-സ്റ്റേജ് ഡോക്കർഫയൽ, ഡോക്കർ-കംപോസ്, കുബർനെറ്റസ് മാനിഫെസ്റ്റുകൾ, അല്ലെങ്കിൽ ഒരു ഹെൽം ചാർട്ട് — നിങ്ങൾ സ്വന്തമാക്കുകയും കമ്മിറ്റ് ചെയ്യുകയും ചെയ്യുന്ന ഫയലുകൾ. |
test.generate | നിർമ്മിച്ച ആപ്പിനായുള്ള യൂണിറ്റ് / API / E2E സ്യൂട്ടുകൾ, കൂടാതെ ഒരു ആവശ്യകത-ടു-ടെസ്റ്റ് traceability matrix എന്നിവ ഉണ്ടാക്കുക. |
test.verify | ഒരു ടെസ്റ്റ് സ്യൂട്ട് (pytest, vitest, jest, Playwright) പ്രവർത്തിപ്പിക്കുകയും അതിന്റെ പാസ് നിരക്കിനെ അടിസ്ഥാനമാക്കി റൺ ഗേറ്റ് ചെയ്യുകയും ചെയ്യുക. |
security.audit | അറിയപ്പെടുന്ന കേടുപാടുകൾക്കായി ഡിപൻഡൻസികൾ സ്കാൻ ചെയ്യുക, ഹാർഡ്-കോഡ് ചെയ്ത രഹസ്യങ്ങൾക്കായി ട്രീ സ്കാൻ ചെയ്യുക; അലേർട്ട് ഇവന്റുകൾ പ്രസിദ്ധീകരിക്കുകയും ഒരു കണ്ടെത്തൽ റിപ്പോർട്ട് എഴുതുകയും ചെയ്യുക. |
preview | ഉണ്ടാക്കിയ ആപ്പ് ലോക്കലായി ആരംഭിക്കുകയും ഒരു preview.ready ഇവന്റ് വഴി അതിന്റെ തത്സമയ URL റൺ പാനലിൽ (ലിങ്ക് + ഇൻലൈൻ ഫ്രെയിം) പ്രദർശിപ്പിക്കുകയും ചെയ്യുക. |
design.import | ഒരു UI ഡിസൈൻ ചിത്രം (സ്ക്രീൻഷോട്ട്, മോക്കപ്പ്, Figma എക്സ്പോർട്ട്) ഡൗൺസ്ട്രീം ഘട്ടങ്ങൾക്കായി ഒരു ഘടനാപരമായ ഇംപ്ലിമെന്റേഷൻ സ്പെക്കായി മാറ്റുക. |
ഓരോ ഘട്ടവും — തരം പരിഗണിക്കാതെ — വർക്ക്സ്പേസ് ഇവന്റ് ബസിൽ ടൈപ്പ് ചെയ്ത ഇവന്റുകൾ പ്രസിദ്ധീകരിക്കാനും സബ്സ്ക്രൈബ് ചെയ്യാനും കഴിയും, അതിനാൽ ഏജന്റുകൾ DAG വഴി മാത്രമല്ല, ഒരു മെസ്സേജ് ഫാബ്രിക്കിലെ സേവനങ്ങൾ പോലെ ഏകോപിപ്പിക്കുന്നു:
lifecycle, agent,
business, data, system, schedule, chat,
external, അല്ലെങ്കിൽ alert — സബ്സ്ക്രിപ്ഷനുകളിലും റീപ്ലേയിലും ഫിൽട്ടർ ചെയ്യാവുന്നതാണ്.trigger (ഒരു പൊരുത്തപ്പെടുന്ന ഇവന്റ് എത്തുമ്പോൾ ഘട്ടം പ്രവർത്തിക്കുന്നു; പാർക്ക് ചെയ്ത ഘട്ടങ്ങളുള്ള ഒരു റൺ കേൾക്കുന്നു എന്ന നിലയിൽ നിലനിൽക്കുന്നു), gate (മനുഷ്യന്റെ ക്ലിക്കിന് പകരം ഒരു ഇവന്റ് അംഗീകരിക്കുന്ന ഒരു മെഷീൻ ഗേറ്റ്), data (പേലോഡ് ഘട്ടത്തിന്റെ സന്ദർഭത്തിലേക്ക് ലയിപ്പിക്കുന്നു).agent.<stage-id>.request എന്ന വിലാസത്തിലേക്ക് പ്രസിദ്ധീകരിച്ച് ആരംഭിക്കാൻ കഴിയും.triggers: ബ്ലോക്ക് ഇൻബൗണ്ട് webhooks,
cron schedules, events, അല്ലെങ്കിൽ ചാറ്റ് എന്നിവയിൽ ആരംഭിക്കാൻ അതിനെ സജ്ജമാക്കുന്നു — സ്റ്റുഡിയോ അടച്ചിരിക്കുമ്പോൾ പോലും.ഇവന്റുകളോട് പ്രതികരിക്കുന്ന ഏജന്റുകൾക്ക് ഒരു durable named queue പ്രഖ്യാപിക്കാം, അതുവഴി ഏജന്റ് തിരക്കിലായിരിക്കുമ്പോഴോ ഒരു റൺ സജ്ജമാകുന്നതിന് മുമ്പോ, പൊരുത്തപ്പെടുന്ന ഇവന്റുകൾ നഷ്ടപ്പെടാതിരിക്കും. ഒരു ട്രിഗർ സബ്സ്ക്രിപ്ഷനിൽ, queue: <name> എന്ന് സജ്ജമാക്കുക — എഞ്ചിൻ ആ വിഷയത്തെ വർക്ക്സ്പേസ് ഇവന്റ് ബസിലെ ഒരു FIFO ക്യൂവിലേക്ക് ബന്ധിപ്പിക്കുന്നു (.deepcerebra/workflows/events/queues/ എന്നതിൽ സൂക്ഷിക്കുന്നു). അതിനുശേഷം പ്രസിദ്ധീകരിക്കുന്ന പൊരുത്തപ്പെടുന്ന ഓരോ ഇവന്റും ക്യൂവിൽ ശേഖരിക്കപ്പെടുന്നു; സ്റ്റേജ് പ്രവർത്തിപ്പിക്കാൻ തയ്യാറാകുമ്പോൾ, എഞ്ചിൻ oldest-first ക്രമത്തിൽ ഇവന്റുകൾ എടുക്കുകയും ഓരോന്നായി ഉപയോഗിക്കുകയും ചെയ്യുന്നു.
count — സബ്സ്ക്രിപ്ഷൻ തൃപ്തിപ്പെടുത്തുന്നതിന് മുമ്പ് N ക്യൂവിൽ ചേർത്ത (അല്ലെങ്കിൽ ഡെലിവർ ചെയ്ത) ഇവന്റുകൾ ആവശ്യമാണ് (നിരവധി വർക്കർമാർ റിപ്പോർട്ട് ചെയ്യേണ്ടിവരുമ്പോൾ ഇത് ഉപയോഗപ്രദമാണ്).GET /api/workflow/queues ഡെപ്ത്തും ബൈൻഡിംഗുകളും ലിസ്റ്റ് ചെയ്യുന്നു;
GET /api/workflow/queues/{name} തീർപ്പാക്കാത്ത ഇവന്റുകൾ കാണിക്കുന്നു; ചാറ്റ് ഏജന്റുകൾക്ക്
event_queue_status ഉം pop_queued_event ഉം വിളിക്കാൻ കഴിയും.events:
subscribe:
- topic: ticket.created
mode: trigger
queue: triage-inbox # durable FIFO — events wait here for this agent
map:
payload.ticket_id: ticket_idഒരു സെമാഫോർ, പങ്കിട്ട (സംരക്ഷിത) ഒരു റിസോഴ്സിൽ ഒരേ സമയം എത്ര ടാസ്ക്കുകൾക്ക് പ്രവർത്തിക്കാൻ കഴിയുമെന്ന് പരിമിതപ്പെടുത്തുന്നു:
എഴുതുന്ന ഒരു ഡാറ്റാബേസ്, ഒരു ഗ്ലോബൽ വേരിയബിൾ സ്റ്റോർ, ഒരു ഫയൽ, അല്ലെങ്കിൽ ഒരു റേറ്റ്-ലിമിറ്റഡ് എക്സ്റ്റേണൽ ഏജൻ്റ്. semaphore: ഉപയോഗിച്ച് ഏതൊരു
സ്റ്റേജിലും ഒരെണ്ണം ചേർക്കുക — സ്റ്റേജിൻ്റെ പ്രവർത്തനം ആരംഭിക്കുന്നതിന് മുമ്പ്, പേര് നൽകിയിട്ടുള്ള വർക്ക്സ്പെയ്സ് സെമാഫോറിൻ്റെ ഒരു പെർമിറ്റ് എഞ്ചിൻ നേടുന്നു;
സ്റ്റേജ് പരാജയപ്പെട്ടാലും, അതിനുശേഷം പെർമിറ്റ് എല്ലായ്പ്പോഴും റിലീസ് ചെയ്യപ്പെടുന്നു.
permits: 1 ഇതിനെ ഒരു മ്യൂട്ടക്സ് ആക്കുന്നു: ഒരു സമയം ഒരു ടാസ്ക് മാത്രം (വർക്ക്സ്പെയ്സിലെ എല്ലാ പാരലൽ റണ്ണുകളിലും)
നിർണ്ണായക ഘട്ടം നടപ്പിലാക്കുന്നു; ഹോൾഡർ പൂർത്തിയാക്കുന്നത് വരെ മറ്റെല്ലാ ടാസ്ക്കുകളും കാത്തിരിക്കുന്നു.
timeout_s വരെ ഒരു അനുമതിക്കായി തടസ്സപ്പെടുന്നു; വിഭവം ശേഷിയിൽ തുടരുകയാണെങ്കിൽ, എന്നെന്നേക്കുമായി കുടുങ്ങിപ്പോകുന്നതിനു പകരം ഘട്ടം ദൃശ്യപരമായി പരാജയപ്പെടുന്നു.ttl_s വഹിക്കുന്നു; ഒരു ഹോൾഡർ റിലീസ് ചെയ്യാതെ ക്രാഷ് ചെയ്യുകയാണെങ്കിൽ, പെർമിറ്റ് സ്വയമേവ കാലഹരണപ്പെടുന്നു, അതിനാൽ വിഭവം ഒരിക്കലും ഡെഡ്-ലോക്ക് ആകില്ല.semaphore.<name>.waiting,
.acquired, കൂടാതെ .released സിസ്റ്റം ഇവന്റുകൾ; GET /api/workflow/semaphores
ശേഷി, കൈവശമുള്ളവർ, ലഭ്യമായ പെർമിറ്റുകൾ എന്നിവ കാണിക്കുന്നു.acquire_semaphore, release_semaphore,
semaphore_status ടൂളുകൾ ഒരു വർക്ക്ഫ്ലോയ്ക്ക് പുറത്ത് അഡ്-ഹോക്ക് നിർണായക വിഭാഗങ്ങളെ ഏകോപിപ്പിക്കുന്നു.semaphore:
name: emr-db-writer
permits: 1 # mutex — one writer at a time
timeout_s: 300 # fail if still waiting after 5 minutes
ttl_s: 900 # auto-release crashed holders after 15 minutesRendezvous അടുത്ത ഘട്ടം മുന്നോട്ട് പോകുന്നതിന് മുമ്പ് ഒന്നിലധികം ഇവന്റ് വ്യവസ്ഥകൾ എല്ലാം പാലിക്കുന്നത് വരെ കാത്തിരിക്കുന്നു — "ആദ്യം നടക്കുന്ന ഇവന്റ് വിജയിക്കും" എന്നതിൻ്റെ വിപരീതം. സ്റ്റേജിന്റെ events: ബ്ലോക്കിൽ join: all എന്ന് നൽകുക: സ്റ്റേജ് പ്രവർത്തിക്കുന്നതിന് മുമ്പ് ഓരോ ട്രിഗർ സബ്സ്ക്രിപ്ഷനും പാലിക്കപ്പെടണം. നിരവധി ഏജന്റുമാർ (അല്ലെങ്കിൽ ഒരു ഏജന്റിൽ നിന്നുള്ള നിരവധി റിപ്പോർട്ടുകൾ) ചെക്ക് ഇൻ ചെയ്യേണ്ടിവരുമ്പോൾ, ഓരോ സബ്സ്ക്രിപ്ഷനുമുള്ള count: N എന്നതുമായി ഇത് സംയോജിപ്പിക്കുക — ഉദാഹരണത്തിന്, ഒരു റിലീസ് സ്റ്റേജ് പ്രവർത്തിക്കുന്നതിന് മുമ്പുള്ള ഡിസൈൻ സൈൻ-ഓഫ്, ടെസ്റ്റ് പൂർത്തിയാക്കൽ, സുരക്ഷാ അനുമതി എന്നിവ.
join: any (സ്ഥിരസ്ഥിതി) — ആദ്യ ട്രിഗർ സബ്സ്ക്രിപ്ഷൻ തൃപ്തിപ്പെടുത്തുമ്പോൾ ഘട്ടം പ്രവർത്തിക്കുന്നു.join: all — സംഗമം: ഓരോ ട്രിഗർ സബ്സ്ക്രിപ്ഷനും (ഓരോന്നിനും അതിൻ്റേതായ topic,
class filter, കൂടാതെ ഓപ്ഷണലായ count) തൃപ്തിപ്പെടുത്തണം; അപ്പോൾ മാത്രമേ ഘട്ടം പ്രവർത്തിപ്പിക്കാൻ കഴിയൂ.trigger_events ആയി രേഖപ്പെടുത്തുകയും
inputs.events (പേലോഡുകളുള്ള ഇവന്റ് ഒബ്ജക്റ്റുകളുടെ ഒരു ലിസ്റ്റ്) ആയി ടെംപ്ലേറ്റുകളിലേക്ക് എക്സ്പോസ് ചെയ്യുകയും ചെയ്യുന്നു.events:
join: all # rendezvous — wait for EVERY subscription below
subscribe:
- topic: design.approved
mode: trigger
- topic: tests.passed
mode: trigger
- topic: security.cleared
mode: trigger
count: 1ചാറ്റ് ഏജന്റ് ഉപയോഗിക്കുന്ന അതേ രജിസ്ട്രിയിൽ നിന്ന് ഘട്ടങ്ങൾ ടൂളുകൾ തിരഞ്ഞെടുക്കുന്നു:
create_database, apply_migrations, dump_schema എന്നിവയും.docker_build / docker_push, കമ്പോസ് അപ്പ്/ഡൗൺ, SSH, ക്ലൗഡ്-CLI ഡിപ്ലോയ്മെന്റുകൾ (Fly, Render, Railway, Vercel), സിമുലേഷൻ-സുരക്ഷിതവും.Class.method) ഗണിതം, സിഗ്നൽ പ്രോസസ്സിംഗ്, കൺട്രോളുകൾ, സ്റ്റാറ്റിസ്റ്റിക്സ് എന്നിവയിലും അതിലേറെ കാര്യങ്ങളിലും./v1 API CI-ക്കും ഇന്റഗ്രേഷനുകൾക്കുമായി റണ്ണുകൾ, ഇവന്റുകൾ, ട്രിഗറുകൾ, ടെംപ്ലേറ്റുകൾ, ജനറേഷൻ എന്നിവ എക്സ്പോസ് ചെയ്യുന്നു.db.provision → ഇംപ്ലിമെന്റേഷൻ → ഉണ്ടാക്കിയ ടെസ്റ്റുകൾ → സുരക്ഷാ ഓഡിറ്റ് → ഡിപ്ലോയ് പാക്കേജിംഗ് → CI ജനറേഷൻ എന്നിവയെ പാക്കേജിംഗിന് മുമ്പ് ഒരു ഹ്യൂമൻ ഗേറ്റ് ഉപയോഗിച്ച് ബന്ധിപ്പിക്കുന്നു — മിനിറ്റുകൾക്കുള്ളിൽ നിങ്ങൾക്ക് അനുരൂപമാക്കാൻ കഴിയുന്ന ഒരു പൂർണ്ണമായ ബ്രീഫ്-ടു-പ്രൊഡക്ഷൻ പാത.പ്രവചനാത്മക ടാബ് പൂർത്തീകരണം എഡിറ്ററിൽ ടൈപ്പ് ചെയ്യുമ്പോൾ ഇൻലൈൻ, ഫിൽ-ഇൻ-ദി-മിഡിൽ കോഡ് നിർദ്ദേശങ്ങൾ നൽകുന്നു — Tab ഉപയോഗിച്ച് ഒരു നിർദ്ദേശം സ്വീകരിക്കുക. ഇത് എഞ്ചിനിലും വെബ് എഡിറ്ററിലും ഓപ്റ്റ്-ഇൻ ആണ്.
DCC_TAB_COMPLETE=1 സജ്ജീകരിക്കുക. എഡിറ്റർ എഞ്ചിന്റെ
POST /api/complete എൻഡ്പോയിന്റ് വിളിക്കുന്നു, ഇത് കഴ്സറിൽ ചേർക്കേണ്ട ടെക്സ്റ്റ് മാത്രം തിരികെ നൽകുന്നു.VITE_TAB_COMPLETE=1 ഉപയോഗിച്ച്, അല്ലെങ്കിൽ റൺടൈമിൽ
localStorage.setItem('dcc.tabComplete', '1') (തുടർന്ന് റീലോഡ് ചെയ്യുക) ഉപയോഗിച്ച് പ്രവർത്തനക്ഷമമാക്കുക.നിങ്ങളുടെ പ്ലാനും ഉപയോഗവും കൈകാര്യം ചെയ്യാൻ സൈഡ്ബാറിൽ നിന്ന് Billing തുറക്കുക. AI ഉപയോഗം അടിസ്ഥാന മോഡലുകൾ ഉപയോഗിക്കുന്ന ടോക്കണുകളെ അടിസ്ഥാനമാക്കി U.S.-ഡോളർ ക്രെഡിറ്റുകളിൽ അളക്കുന്നു.
| പ്ലാൻ | പ്രതിമാസ വില | ഉൾപ്പെടുത്തിയ പ്രതിമാസ AI ഉപയോഗം |
|---|---|---|
| ബേസിക് | $20 | $10 |
| പ്രോ | $75 | $30 |
| അന്തിമം | $200 | $150 |
ഒരു ഗേറ്റ്വേ API കീ (ഒരു പേഴ്സണൽ ആക്സസ് ടോക്കൺ) DeepCerebra പബ്ലിക് API-യും CLI-യും പ്രോഗ്രാമാറ്റിക്കായി ഉപയോഗിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.
read, chat, code, agent — എന്നീ സ്കോപ്പുകളും ദിവസങ്ങളിൽ ഒരു ഓപ്ഷണൽ കാലാവധിയും (ഒഴിഞ്ഞത് = ഒരിക്കലുമില്ല) തിരഞ്ഞെടുക്കുക.deepcerebra.ai-ലെ CLI അല്ലെങ്കിൽ API ഉപയോഗിച്ച് ഇത് ഉപയോഗിക്കുക:
dcc config set endpoint https://deepcerebra.ai
dcc config set api-key <your-key>
# or as a Bearer token
curl -H "Authorization: Bearer <your-key>" https://deepcerebra.ai/v1/...നിങ്ങൾക്ക് എപ്പോൾ വേണമെങ്കിലും ഒരു കീ പുനർനാമകരണം ചെയ്യാനോ ഇല്ലാതാക്കാനോ (റദ്ദാക്കാനോ) കഴിയും; ഓരോ കീയും അതിന്റെ പ്രിഫിക്സ്, സ്കോപ്പുകൾ, ഉണ്ടാക്കിയ/കാലാവധി, അവസാനമായി ഉപയോഗിച്ച തീയതി എന്നിവ കാണിക്കുന്നു.
Chrome, Edge, അല്ലെങ്കിൽ Brave-ലേക്ക് മാറുക, അല്ലെങ്കിൽ പകരം Open from Git ഉപയോഗിക്കുക.
Stop ക്ലിക്ക് ചെയ്യുക, തുടർന്ന് ഒരു വ്യക്തമായ സൂചനയോ നിയന്ത്രണമോ ഉപയോഗിച്ച് വീണ്ടും എഴുതുക.
dcc-bridge കണക്ടർ പ്രവർത്തിക്കുന്നുണ്ടെന്നും ഉപകരണം ഓൺലൈൻ ആണെന്നും സ്ഥിരീകരിക്കുക.1234) ഒരു മോഡൽ ലോഡ് ചെയ്തുകൊണ്ട് പ്രവർത്തനക്ഷമമാക്കിയിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക.--gateway ആയി
(wss://deepcerebra.ai or wss://deepcerebra.io) — ഈ രണ്ട് സൈറ്റുകളും വ്യത്യസ്ത വിന്യാസങ്ങളാണ്, ഒരു സൈറ്റിൽ നിന്നുള്ള ടോക്കൺ മറ്റൊന്നിൽ പ്രവർത്തിക്കില്ല.ഒരു പുൾ റിക്വസ്റ്റ് തുറക്കാൻ Integrate ഉപയോഗിക്കുന്നതിന് മുമ്പ് ഒരു വർക്കിംഗ് ബ്രാഞ്ച് തുറക്കുക അല്ലെങ്കിൽ ഉണ്ടാക്കുക.
ഇപ്പോഴും കുടുങ്ങിയോ? support@deepcerebra.ai-ൽ ബന്ധപ്പെടുക.
Discovery എന്നത് നിങ്ങളുടെ ഡാറ്റാബേസുകൾക്കും ഡോക്യുമെന്റുകൾക്കുമുള്ള ഒരു അന്വേഷണാത്മക ചാറ്റ്ബോട്ട് ആണ്.
ഒരൊറ്റ ചോദ്യത്തിന് ഉത്തരം നൽകുന്നതിന് പകരം, ഇത് ഒരു അനലിസ്റ്റിനെപ്പോലെ പ്രവർത്തിക്കുന്നു: ഇത് അനുമാനങ്ങൾ രൂപീകരിക്കുന്നു,
ഒരു കൂട്ടം സംരക്ഷിത അന്വേഷണങ്ങൾ (SQL, graph, document search, schema checks, web corroboration) നടത്തുന്നു, തെളിവുകൾ
നിരാകരിക്കുന്ന വിശദീകരണങ്ങൾ ഒഴിവാക്കുന്നു, കൂടാതെ ചാർട്ടുകളും സുതാര്യമായ ചെലവ് രസീതും സഹിതം ഒരു അടിസ്ഥാനപരമായ ഉത്തരം
സമന്വയിപ്പിക്കുന്നു. ആക്റ്റിവിറ്റി റെയിലിലെ കോമ്പസ് ഐക്കണിൽ നിന്ന് ഇത് തുറക്കുക
(/app/discovery).
ഒരു സ്പേസ് ഒരു ചോദ്യത്തിന് ആവശ്യമായ എല്ലാ കാര്യങ്ങളും ഒരുമിച്ച് കൂട്ടിച്ചേർക്കുന്നു: ഡാറ്റാബേസ് കണക്ഷനുകൾ, ഡോക്യുമെന്റ് ശേഖരങ്ങൾ, അനലിസ്റ്റിനുള്ള നിർദ്ദേശങ്ങൾ, ബഡ്ജറ്റുകൾ. + New space ഉപയോഗിച്ച് ഒരെണ്ണം സൃഷ്ടിക്കുക, തുടർന്ന് വലതുവശത്തുള്ള സെറ്റപ്പ് പാനൽ ഉപയോഗിച്ച്:
ഒരു സഹപ്രവർത്തകനോട് ചോദിക്കുന്നതുപോലെ ഒരു ചോദ്യം ടൈപ്പ് ചെയ്യുക — ഉദാഹരണത്തിന് "മാർച്ചിൽ MRI സ്കാൻ വോളിയം കുറഞ്ഞത് എന്തുകൊണ്ട്?". അന്വേഷണ ബോർഡ് മുഴുവൻ പ്രക്രിയയും തത്സമയം സ്ട്രീം ചെയ്യുന്നു:
തുടർ ചോദ്യങ്ങൾ അതേ ത്രെഡ് തുടരുന്നു, അതിനാൽ അനലിസ്റ്റ് അതിന്റെ സന്ദർഭം നിലനിർത്തുന്നു.
ചാർട്ടുകൾ അന്വേഷണ ബോർഡിൽ ഇൻലൈനായി റെൻഡർ ചെയ്യുന്നു. പൂർണ്ണമായ ചോദ്യം — ഉത്തരം, അനുമാനങ്ങൾ, തെളിവുകൾ, ചാർട്ടുകൾ എന്നിവ — ഒരു സ്വയം അടങ്ങിയ HTML റിപ്പോർട്ടായോ അല്ലെങ്കിൽ നിയോൺ ഡിസൈൻ സിസ്റ്റം ഉപയോഗിച്ച് സ്റ്റൈൽ ചെയ്ത പ്രിന്റ്-ക്വാളിറ്റി PDF ആയോ ഡൗൺലോഡ് ചെയ്യാൻ Export ഉപയോഗിക്കുക.
ഓരോ സ്പേസിനും ഓരോ ചോദ്യത്തിനും ബഡ്ജറ്റുകൾ ഉണ്ട്: പരമാവധി അന്വേഷണങ്ങളുടെ എണ്ണം, അന്വേഷണ റൗണ്ടുകൾ, സെക്കൻഡുകൾ, USD. എഞ്ചിൻ പരിധിയിൽ വൃത്തിയായി നിർത്തുകയും അതുവരെ കണ്ടെത്തിയ കാര്യങ്ങൾ റിപ്പോർട്ട് ചെയ്യുകയും ചെയ്യുന്നു. ഓരോ അന്വേഷണത്തിന്റെയും ചെലവ് രസീതിൽ രേഖപ്പെടുത്തുന്നു, അതിനാൽ ചെലവ് എവിടെ പോയി എന്ന് നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും അറിയാൻ കഴിയും.
/v1/discovery/* എന്നതിന് കീഴിൽ discovery സ്കോപ്പ്
ഉള്ള ഒരു PAT ഉപയോഗിച്ച് ലഭ്യമാണ് (Account → API Tokens എന്നതിന് കീഴിൽ ഇത് സൃഷ്ടിക്കുക). സ്ട്രീമിംഗ് ചോദ്യങ്ങൾ
SSE ഉപയോഗിക്കുന്നു. ബാഹ്യ എക്സിക്യൂട്ടർമാർക്ക് Thinking API (/v1/think/*, സ്കോപ്പ് think) വഴി
അന്വേഷണാത്മക ആസൂത്രണം മാത്രം കടമെടുക്കാൻ കഴിയും.pip install deepcerebra-discovery, then
DiscoveryClient(base_url, token).ask(space_id, question).discovery.ask) ഏതൊരു വർക്ക്ഫ്ലോയിലേക്കും വലിച്ചിടുക; ഉത്തരവും ചാർട്ടുകളും രസീതും താഴെയുള്ള ഘട്ടങ്ങളിലേക്ക്
ഒഴുകുന്നു.discovery_ask, discovery_list_spaces എന്നിവ MCP ടൂളുകളായി
എക്സ്പോസ് ചെയ്യുന്നു, അതിനാൽ ബാഹ്യ MCP ക്ലയന്റുകൾക്കും അന്വേഷണങ്ങൾ നടത്താൻ കഴിയും.