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 માં પ્લાન પસંદ કરી શકો છો.સાઇન ઇન કર્યા પછી તમે વર્કબેન્ચમાં ઉતરો છો, જે દરેક પેનને એક સ્ક્રીનમાં મૂકે છે:
લેઆઉટને ફરીથી સંતુલિત કરવા માટે એડિટર અને ચેટ વચ્ચે સ્પ્લિટરને ખેંચો, અને ટર્મિનલનું કદ બદલવા માટે હોરિઝોન્ટલ સ્પ્લિટરને ખેંચો. ડાબી સાઇડબાર Workspace, Extensions, API Keys, Billing અને Feedback પર પણ નેવિગેટ કરે છે.
repo સ્કોપ (ક્લાસિક) અથવા Contents + Pull requests સાથે ફાઇન-ગ્રેઇન્ડ ટોકનનો ઉપયોગ કરો; GitLab માટે api સ્કોપનો ઉપયોગ કરો. તમારું ટોકન સર્વર પર સંગ્રહિત થાય છે — ફક્ત ફાઇલ સામગ્રી બ્રાઉઝરમાં ખેંચાય છે.owner/name તરીકે ટાઇપ કરો (તમારું શોધવા માટે સૂચિને ફિલ્ટર કરો), પછી એક branch પસંદ કરો.dcc/my-feature) ને ટિક કરો જેથી તમારું કાર્ય ડિફોલ્ટ બ્રાન્ચથી અલગ રહે.ચેટ હિસ્ટરી ખુલ્લા પ્રોજેક્ટ સાથે જોડાયેલી છે. ફોલ્ડર્સ સ્વિચ કરવાથી આપમેળે નવું સત્ર શરૂ થાય છે અને તે ફોલ્ડરના પાછલા સત્રો લોડ થાય છે, સૌથી તાજેતરનું ફરીથી ખોલવામાં આવે છે જેથી તમે જ્યાંથી છોડ્યું હતું ત્યાંથી ફરી શરૂ કરી શકો.
DeepCerebra આંતરિક રીતે ઉપયોગ કરે છે તે ફોલ્ડર્સ — .deepcerebra, .sessions — ટ્રીમાં દેખાય છે પરંતુ ડિફોલ્ટ રૂપે સંકુચિત હોય છે જેથી તેઓ તમારા સ્રોતને અવ્યવસ્થિત ન કરે.
તમે સાદી ભાષામાં શું કરવા માંગો છો તેનું વર્ણન કરો — પ્રશ્ન પૂછો, સુવિધાની વિનંતી કરો અથવા બગ તરફ નિર્દેશ કરો. શ્રેષ્ઠ પરિણામ મેળવવા માટે ફાઇલો, ફ્રેમવર્ક અને મર્યાદાઓ વિશે ચોક્કસ રહો. સંબંધિત ફાઇલોને પ્રોમ્પ્ટમાં ખેંચીને જોડો.
પ્રતિભાવો Cursor ની જેમ ગોઠવાયેલા છે: એજન્ટનું તર્ક ડિલિવરેબલ થી અલગ પડે છે. દરેક પ્રતિભાવ બ્લોકમાં તેના ઉપર-જમણા ખૂણામાં કોપી આઇકન હોય છે જેથી તમે તૈયાર રિપોર્ટ, દસ્તાવેજ અથવા તમે ચલાવવાના કમાન્ડને કોપી કરી શકો.
html.parser ને બદલે lxml નો ઉપયોગ કરો").@deepcerebra સાથે ચેટમાં એજન્ટને બોલાવો છો, અને [deep] જેવા પ્રિફિક્સ ઊંડા તર્કની વિનંતી કરે છે.પ્રોમ્પ્ટની બાજુમાં મોડ સિલેક્ટર માંથી એક મોડ પસંદ કરો. દરેક મોડ એજન્ટ કેટલું પ્લાન કરે છે અને કેટલી મુક્તપણે સંપાદિત કરે છે તે ટ્યુન કરે છે:
| મોડ | તે શું કરે છે | ક્યારે ઉપયોગ કરવો… |
|---|---|---|
| Agent | તમારા પ્રોજેક્ટમાં સ્વાયત્ત રીતે યોજના બનાવે છે અને સંપાદિત કરે છે | તમે સહાયકને ફેરફારને એન્ડ-ટુ-એન્ડ અમલમાં મૂકવા માંગો છો |
| Ask | સંપાદન કર્યા વિના તમારા કોડ વિશેના પ્રશ્નોના જવાબ આપે છે | તમે કોડબેઝને સમજવા માંગો છો |
| Plan | કોઈપણ સંપાદન પહેલાં એક અભિગમનો ડ્રાફ્ટ તૈયાર કરે છે | કાર્ય મોટું છે અથવા પહેલાં સમાધાન કરવા માટે ટ્રેડ-ઓફ્સ છે |
| Edit | વર્તમાન સંદર્ભમાં કેન્દ્રિત સંપાદનો કરે છે | તમે એક નાનો, લક્ષિત ફેરફાર કરવા માંગો છો |
જ્યારે એજન્ટ ફાઇલ ફેરફારો પ્રસ્તાવિત કરે છે, ત્યારે ચેટ ઇનપુટની ઉપર એક Proposed Changes પેનલ દેખાય છે, જેમાં ઉમેરાયેલી (+) અને દૂર કરાયેલી (−) લાઇન ગણતરીઓ સાથે દરેક સ્પર્શેલી ફાઇલની સૂચિ હોય છે.
applied તરીકે ચિહ્નિત થાય છે (અને જ્યારે વાસ્તવિક ફોલ્ડરમાં લખવામાં આવે ત્યારે · disk).બિલ્ડ્સ, ટેસ્ટ્સ અને સ્ક્રિપ્ટ્સ ચલાવવા માટે એડિટરની નીચે ટર્મિનલને ટૉગલ કરો. તમારી અધિકૃતતા સાથે, એજન્ટ કમાન્ડ્સ ચલાવી શકે છે અને તેના કાર્યને ચકાસવા માટે તેમનું આઉટપુટ વાંચી શકે છે; લાંબા સમય સુધી ચાલતા કમાન્ડ્સ આઉટપુટને સ્ટ્રીમ કરે છે જેથી તમે પ્રગતિ જોઈ શકો. જ્યારે તમને તેની જરૂર ન હોય ત્યારે તેના હેડરમાંથી ટર્મિનલ બંધ કરો.
મોટા લક્ષ્યો માટે, Plan મોડનો ઉપયોગ કરો (અથવા એજન્ટને પહેલા પ્લાન કરવા કહો). પ્લાનર તમારા પ્રોજેક્ટને સ્કેન કરે છે, લક્ષ્યને ડિપેન્ડન્સી-અવેર ટાસ્ક માં વિઘટિત કરે છે, અને દરેકને યોગ્ય નિષ્ણાત (આર્કિટેક્ટ, કોડર, ટેસ્ટર, ડોક્સ) ને સોંપે છે.
પ્રોમ્પ્ટની બાજુમાં મોડેલ પીકર ખોલો. વિકલ્પો આ રીતે જૂથબદ્ધ છે:
Auto પર, DeepCerebra ટિયર્ડ, અનુકૂલનશીલ રૂટિંગ નો ઉપયોગ કરે છે: સરળ કાર્યો ઝડપી, આર્થિક મોડેલ પર જાય છે, જ્યારે જટિલ અથવા પ્લાનિંગ-હેવી કાર્ય (ઉદાહરણ તરીકે, Plan મોડ) મજબૂત મોડેલ પર રૂટ થાય છે. આ ખર્ચ અને ગુણવત્તાને આપમેળે સંતુલિત કરે છે, તેથી તમારે ભાગ્યે જ મેન્યુઅલી પસંદ કરવાની જરૂર પડે છે.
તમે મીટર્ડ પ્લેટફોર્મ ઉપયોગને બદલે તમારા પોતાના પ્રદાતા એકાઉન્ટ દ્વારા વિનંતીઓને રૂટ કરી શકો છો.
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) સુધી મર્યાદિત હોય છે. તમારા પૂર્વ-ગોઠવેલા CLIs સાથે તમારા વાસ્તવિક પ્રોજેક્ટ ફોલ્ડર્સમાં કામ કરવા માટે, કનેક્ટર શરૂ કરતી વખતે તેમને સ્પષ્ટપણે મંજૂરી આપો:
# 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-બેક્ડ પ્રોજેક્ટ ખુલ્લો હોવાથી, Explorer માં એક બ્રાન્ચ બાર દેખાય છે જે તમારી વર્તમાન બ્રાન્ચ અને બે ક્રિયાઓ બતાવે છે:
main) માં pull request ખોલો. તમે કાર્યકારી બ્રાન્ચ પર હોવા જોઈએ, ડિફોલ્ટ બ્રાન્ચ પર નહીં.જો પુશ વેબહૂક સક્ષમ હોય, તો જ્યારે ટીમના સભ્યો પુશ કરે ત્યારે Explorer આપમેળે રિફ્રેશ થાય છે, દરેકને સિંકમાં રાખે છે — 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 resources અથવા prompt templates ને ખુલ્લા પાડે છે, તો એજન્ટ આપમેળે તેમનો ઉપયોગ કરવા માટે ટૂલ્સ મેળવે છે (mcp_list_resources, mcp_read_resource, mcp_list_prompts, mcp_get_prompt).
રિમોટ સર્વર પર auth બ્લોક ઉમેરો. Secrets ${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/…, પ્રોજેક્ટ્સમાં તમારી વ્યક્તિગત ડિફોલ્ટ્સ.Rules એ સતત સૂચનાઓ છે — કોડિંગ ધોરણો, આર્કિટેક્ચર કન્વેન્શન્સ, ડોમેન સંદર્ભ — જે એજન્ટના સિસ્ટમ પ્રોમ્પ્ટમાં ઇન્જેક્ટ કરવામાં આવે છે. તેઓ .deepcerebra/steering/ હેઠળ Markdown ફાઇલો તરીકે રહે છે, ઉપરાંત હંમેશા ચાલુ રહેલું AGENTS.md ધોરણ. Frontmatter નિયંત્રિત કરે છે કે નિયમ ક્યારે લોડ થાય છે:
---
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) આપે છે.
Skills એ ફરીથી વાપરી શકાય તેવી પ્લેબુક્સ છે જે એજન્ટ માંગ પર લોડ કરે છે. દરેક skill એ .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 કૌશલ્યને ફક્ત મેન્યુઅલ બનાવવા માટે.
Hooks લાઇફસાયકલ ઇવેન્ટ્સ પર ઓટોમેશન ચલાવે છે. તેમને .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
(કર્સર/ક્લાઉડ સ્પેલિંગ પણ સ્વીકાર્ય છે). એક ક્રિયા કાં તો shell (આદેશ ચલાવો) અથવા
agentPrompt (એજન્ટને પૂછો) છે. એક preToolUse હૂક તે જે ટૂલ કૉલને અટકાવે છે તેના માટે મંજૂરી આપી શકે છે,
ના પાડી શકે છે, અથવા પૂછી શકે છે.
Subagents એ નિષ્ણાત એજન્ટ્સ છે જેને તમે વ્યાખ્યાયિત કરો છો અને સોંપો છો. દરેક .deepcerebra/agents/ હેઠળ frontmatter ઉપરાંત બોડી (તેનો સિસ્ટમ પ્રોમ્પ્ટ) સાથેની 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 (ફેન-આઉટ) સાથે સોંપણી કરે છે.
એક plugin નિયમો, skills, hooks, subagents અને MCP સર્વર્સને .deepcerebra/plugins/<name>/ હેઠળ એક ઇન્સ્ટોલ કરી શકાય તેવા પેકેજમાં બંડલ કરે છે, જે plugin.json મેનિફેસ્ટ દ્વારા વર્ણવવામાં આવે છે:
{
"name": "Acme Standards",
"version": "1.2.0",
"description": "Acme rules + skills + review agents.",
"enabled": true
}પ્લગઇન સામગ્રી સૌથી ઓછી પ્રાધાન્યતા પર મર્જ કરવામાં આવે છે, તેથી તમારા પોતાના નિયમો અને skills હંમેશા પ્લગઇનના નિયમોને ઓવરરાઇડ કરે છે. "enabled": false અથવા .disabled માર્કર ફાઇલ સાથે પ્લગઇનને અક્ષમ કરો.
DCC_ORG_CONFIG_DIR ને શેર કરેલ .deepcerebra ડિરેક્ટરી તરફ નિર્દેશ કરીને, અથવા વેબ એપ્લિકેશનમાં નિયમોને Team સ્કોપ પર સેટ કરીને શેર કરેલ ડિફોલ્ટ્સ પ્રકાશિત કરી શકે છે.Workflow Studio એ મલ્ટી-એજન્ટ ઓટોમેશન માટેનું વિઝ્યુઅલ ડિઝાઇનર છે. તમે stages — દરેક એક એજન્ટ, એક નિષ્ણાત પગલું, અથવા એક નિયંત્રણ પ્રિમિટિવ — ને ગ્રાફમાં કંપોઝ કરો છો, તેમને ડિપેન્ડન્સી સાથે જોડો છો, અને લાઇવ પ્રતિ-સ્ટેજ પ્રગતિ, બજેટ અને માનવ-મંજૂરી ગેટ્સ સાથે એન્જિન પર સમગ્ર ઓર્કેસ્ટ્રેશન ચલાવો છો. વર્કફ્લો પોર્ટેબલ YAML/JSON ડેફિનેશન તરીકે સાચવવામાં આવે છે જેને તમે Git માં નિકાસ, આયાત, વર્ઝન કરી શકો છો અને API અથવા CLI માંથી ચલાવી શકો છો.
| Stage kind | તે શું કરે છે |
|---|---|
agent | તમે જોડો છો તે skills અને ટૂલ્સ સાથે એક એજન્ટ વારો. |
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-જજ); થ્રેશોલ્ડથી નીચે નિષ્ફળ. |
db.provision | એક માલિકીનો ડેટા લેયર જનરેટ કરો: ડેટાબેઝ માટે docker-compose, વર્ઝન કરેલ SQL માઇગ્રેશન્સ, સીડ ડેટા, .env ટેમ્પલેટ, અને એક Mermaid ERD; વૈકલ્પિક auth સ્કેફોલ્ડ; SQLite પર તરત જ માઇગ્રેશન્સ લાગુ કરી શકે છે. |
ci.generate | એક તૈયાર-થી-કમિટ CI/CD પાઇપલાઇન (GitHub Actions, GitLab CI, અથવા Azure Pipelines) lint → test → scan → build → deploy અને પર્યાવરણ પ્રમોશન સાથે જનરેટ કરો. |
deploy.package | પ્રોડક્શન ડિપ્લોયમેન્ટ એસેટ્સ જનરેટ કરો: મલ્ટી-સ્ટેજ Dockerfile, docker-compose, Kubernetes manifests, અથવા એક Helm chart — ફાઇલો જે તમારી માલિકીની છે અને તમે કમિટ કરો છો. |
test.generate | બિલ્ટ એપ્લિકેશન માટે યુનિટ / API / E2E સ્યુટ્સ ઉપરાંત એક જરૂરિયાત-થી-ટેસ્ટ ટ્રેસેબિલિટી મેટ્રિક્સ જનરેટ કરો. |
test.verify | એક ટેસ્ટ સ્યુટ (pytest, vitest, jest, Playwright) ચલાવો અને તેના પાસ રેટ પર રનને ગેટ કરો. |
security.audit | જાણીતી નબળાઈઓ માટે ડિપેન્ડન્સીઝ અને હાર્ડ-કોડેડ સિક્રેટ્સ માટે ટ્રીને સ્કેન કરો; એલર્ટ ઇવેન્ટ્સ પ્રકાશિત કરે છે અને તારણોનો રિપોર્ટ લખે છે. |
preview | જનરેટ કરેલી એપ્લિકેશનને સ્થાનિક રીતે શરૂ કરો અને preview.ready ઇવેન્ટ દ્વારા તેના લાઇવ URL ને રન પેનલમાં (લિંક + ઇનલાઇન ફ્રેમ) સપાટી પર લાવો. |
design.import | UI ડિઝાઇન ઇમેજ (સ્ક્રીનશોટ, મોકઅપ, ફિગ્મા એક્સપોર્ટ) ને નીચેના તબક્કાઓ માટે સંરચિત અમલીકરણ સ્પષ્ટીકરણમાં રૂપાંતરિત કરો. |
દરેક સ્ટેજ — પ્રકારને ધ્યાનમાં લીધા વિના — વર્કસ્પેસ ઇવેન્ટ બસ પર ટાઇપ્ડ ઇવેન્ટ્સને પ્રકાશિત અને સબ્સ્ક્રાઇબ કરી શકે છે, જેથી એજન્ટ્સ ફક્ત DAG દ્વારા જ નહીં પરંતુ મેસેજ ફેબ્રિક પર સેવાઓ જેવી રીતે સંકલન કરે છે:
lifecycle, agent, business, data, system, schedule, chat, external, અથવા alert — સબ્સ્ક્રિપ્શન્સ અને રિપ્લેમાં ફિલ્ટર કરી શકાય તેવું.trigger (જ્યારે મેચિંગ ઇવેન્ટ આવે ત્યારે સ્ટેજ ચાલે છે; પાર્ક કરેલા સ્ટેજ સાથેનો રન listening તરીકે રહે છે), gate (માનવ ક્લિકને બદલે ઇવેન્ટ દ્વારા મંજૂર થયેલ મશીન ગેટ), અને data (પેલોડ સ્ટેજના સંદર્ભમાં મર્જ થાય છે).agent.<stage-id>.request પર પ્રકાશિત કરીને શરૂ કરી શકાય છે.triggers: બ્લોક ઇનબાઉન્ડ webhooks, cron schedules, events, અથવા ચેટ પર શરૂ કરવા માટે તેને સજ્જ કરે છે — ભલે Studio બંધ હોય.ઇવેન્ટ્સ પર પ્રતિક્રિયા આપતા એજન્ટ્સ ટકાઉ નામવાળી કતાર ઘોષિત કરી શકે છે જેથી એજન્ટ વ્યસ્ત હોય અથવા રન સાંભળી રહ્યું ન હોય ત્યાં સુધી મેચિંગ ઇવેન્ટ્સ ક્યારેય ખોવાઈ ન જાય. ટ્રિગર સબ્સ્ક્રિપ્શન પર, સેટ કરો queue: <name> — એન્જિન તે વિષયને વર્કસ્પેસ ઇવેન્ટ બસ પર FIFO કતાર સાથે બાંધે છે (.deepcerebra/workflows/events/queues/ હેઠળ સંગ્રહિત). તે બિંદુથી પ્રકાશિત થતી દરેક મેચિંગ ઇવેન્ટ કતારમાં કેપ્ચર થાય છે; જ્યારે સ્ટેજ રન કરી શકાય તેવું બને છે, ત્યારે એન્જિન ઇવેન્ટ્સને સૌથી જૂના-પ્રથમ ક્રમમાં પોપ કરે છે અને તેમને એક પછી એક વાપરે છે.
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 તેને એક mutex બનાવે છે: એક સમયે ફક્ત એક જ કાર્ય (વર્કસ્પેસમાંના તમામ સમાંતર રન પર) નિર્ણાયક પગલું ચલાવે છે; અન્ય દરેક કાર્ય ધારક સમાપ્ત ન થાય ત્યાં સુધી રાહ જુએ છે.
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 minutesરેન્ડેઝવસ રાહ જુએ છે જ્યાં સુધી બહુવિધઇવેન્ટ શરતો બધી પૂરી ન થાય ત્યાં સુધી આગલું પગલું આગળ વધે નહીં — "પ્રથમ ઇવેન્ટ જીતે છે" તેનાથી વિરુદ્ધ. સ્ટેજના events: બ્લોક પર join: all સેટ કરો: સ્ટેજ ચાલે તે પહેલાં દરેક ટ્રિગર સબ્સ્ક્રિપ્શન સંતોષાવું આવશ્યક છે. પ્રતિ-સબ્સ્ક્રિપ્શન count: N સાથે જોડો જ્યારે ઘણા એજન્ટ્સ (અથવા એક એજન્ટના ઘણા અહેવાલો) બધાએ ચેક ઇન કરવું આવશ્યક છે — ઉદાહરણ તરીકે, રિલીઝ સ્ટેજ અમલમાં આવે તે પહેલાં ડિઝાઇન સાઇન-ઓફ, ટેસ્ટ પૂર્ણતા અને સુરક્ષા મંજૂરી.
join: any (ડિફૉલ્ટ) — જ્યારે પ્રથમ ટ્રિગર સબ્સ્ક્રિપ્શન સંતુષ્ટ થાય ત્યારે સ્ટેજ ચાલે છે.join: all — રેન્ડેઝવસ: દરેક ટ્રિગર સબ્સ્ક્રિપ્શન (દરેક તેના પોતાના વિષય, ક્લાસ ફિલ્ટર અને વૈકલ્પિક 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, compose up/down, SSH અને ક્લાઉડ-CLI ડિપ્લોય (Fly, Render, Railway, Vercel), પણ સિમ્યુલેશન-સુરક્ષિત.Class.method)./v1 API CI અને ઇન્ટિગ્રેશન્સ માટે રન, ઇવેન્ટ્સ, ટ્રિગર્સ, ટેમ્પલેટ્સ અને જનરેશનને ખુલ્લા પાડે છે.db.provision → અમલીકરણ → જનરેટ થયેલા ટેસ્ટ્સ → સુરક્ષા ઑડિટ → ડિપ્લોય પેકેજિંગ →
CI જનરેશન, પેકેજિંગ પહેલાં માનવીય ગેટ સાથે — એક સંપૂર્ણ બ્રીફ-ટુ-પ્રોડક્શન પાથ જેને તમે
મિનિટોમાં અનુકૂલિત કરી શકો છો.Predictive Tab completion એડિટરમાં ટાઇપ કરતી વખતે ઇનલાઇન, ફિલ-ઇન-ધ-મિડલ કોડ સૂચનો પ્રદાન કરે છે — Tab સાથે સૂચન સ્વીકારો. તે એન્જિન અને વેબ એડિટર બંને પર ઓપ્ટ-ઇન છે.
DCC_TAB_COMPLETE=1 સેટ કરો. એડિટર
એન્જિનના POST /api/complete એન્ડપોઇન્ટને કૉલ કરે છે, જે કર્સર પર દાખલ કરવા માટે ફક્ત ટેક્સ્ટ પરત કરે છે.VITE_TAB_COMPLETE=1 સાથે બિલ્ડ સમય પર સક્ષમ કરો, અથવા localStorage.setItem('dcc.tabComplete', '1') સાથે રનટાઇમ પર સક્ષમ કરો (પછી ફરીથી લોડ કરો).તમારા પ્લાન અને ઉપયોગનું સંચાલન કરવા માટે સાઇડબારમાંથી Billing ખોલો. AI ઉપયોગ યુ.એસ.-ડોલર ક્રેડિટ્સમાં માપવામાં આવે છે જે અંતર્ગત મોડલ્સ દ્વારા વપરાયેલા ટોકન્સ પર આધારિત છે.
| પ્લાન | માસિક કિંમત | શામેલ માસિક AI ઉપયોગ |
|---|---|---|
| Basic | $20 | $10 |
| Pro | $75 | $30 |
| Ultimate | $200 | $150 |
એક gateway API key (એક પર્સનલ એક્સેસ ટોકન) તમને DeepCerebra જાહેર API અને CLI નો પ્રોગ્રામમેટિક રીતે ઉપયોગ કરવા દે છે.
read, chat, code, agent — અને વૈકલ્પિક સમાપ્તિ દિવસોમાં (ખાલી = ક્યારેય નહીં).તેનો ઉપયોગ CLI અથવા deepcerebra.ai પર 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/...તમે કોઈપણ સમયે કીને rename અથવા delete (revoke) કરી શકો છો; દરેક કી તેનું પ્રિફિક્સ, scopes, બનાવેલ/સમાપ્તિ અને છેલ્લી-વપરાયેલી તારીખ બતાવે છે.
Chrome, Edge, અથવા Brave પર સ્વિચ કરો, અથવા તેના બદલે Open from Git નો ઉપયોગ કરો.
Stop પર ક્લિક કરો, પછી એક નક્કર સંકેત અથવા મર્યાદા સાથે ફરીથી શબ્દો ગોઠવો.
dcc-bridge કનેક્ટર ચાલી રહ્યું છે અને ઉપકરણ ઓનલાઇન બતાવે છે.1234) જેમાં મોડેલ લોડ થયેલું છે.--gateway તરીકે બ્રાઉઝરમાં ઉપયોગ કરો છો તે જ ડોમેન નો ઉપયોગ કરો (wss://deepcerebra.ai અથવા wss://deepcerebra.io) — બે સાઇટ્સ અલગ ડિપ્લોયમેન્ટ્સ છે, અને એકમાંથી ટોકન ક્યારેય બીજા પર કામ કરતું નથી.પુલ રિક્વેસ્ટ ખોલવા માટે Integrate નો ઉપયોગ કરતા પહેલા working branch ખોલો અથવા બનાવો.
હજી પણ અટવાયેલા છો? support@deepcerebra.ai નો સંપર્ક કરો.
Discovery એ તમારા ડેટાબેઝ અને દસ્તાવેજો માટે એક તપાસ કરનાર ચેટબોટ છે.
એક જ ક્વેરી વડે જવાબ આપવાને બદલે, તે એક વિશ્લેષક (analyst) તરીકે કામ કરે છે: તે પૂર્વધારણાઓ (hypotheses) બનાવે છે,
સુરક્ષિત તપાસની શ્રેણી ચલાવે છે (SQL, ગ્રાફ, દસ્તાવેજ શોધ, સ્કીમા તપાસ, વેબ પુષ્ટિ), પુરાવાઓ દ્વારા
નકારવામાં આવેલી સમજૂતીઓને દૂર કરે છે, અને ચાર્ટ અને પારદર્શક ખર્ચની રસીદ સાથે એક આધારભૂત જવાબ સંશ્લેષિત કરે છે.
તેને એક્ટિવિટી રેલ (/app/discovery) માં કંપાસ આઇકન થી ખોલો.
એક Space માં પ્રશ્ન પૂછવા માટે જરૂરી બધું જ શામેલ હોય છે: ડેટાબેઝ કનેક્શન્સ, દસ્તાવેજ સંગ્રહો, વિશ્લેષક માટેની સૂચનાઓ અને બજેટ. + New space વડે એક બનાવો, પછી જમણી બાજુની સેટઅપ પેનલનો ઉપયોગ કરીને આ કરો:
તમે તમારા સહકર્મીને પૂછો તે રીતે પ્રશ્ન ટાઇપ કરો — ઉદાહરણ તરીકે "માર્ચમાં MRI સ્કેનનું પ્રમાણ શા માટે ઘટ્યું?". તપાસ બોર્ડ સમગ્ર પ્રક્રિયાને લાઇવ સ્ટ્રીમ કરે છે:
ફોલો-અપ પ્રશ્નો તે જ થ્રેડને ચાલુ રાખે છે, જેથી વિશ્લેષક તેનો સંદર્ભ જાળવી રાખે છે.
ચાર્ટ્સ તપાસ બોર્ડ પર ઇનલાઇન રેન્ડર થાય છે. સંપૂર્ણ પૂછપરછ — જવાબ, પૂર્વધારણાઓ, પુરાવા અને ચાર્ટ્સ — ને સ્વયં-સમાવિષ્ટ HTML રિપોર્ટ અથવા પ્રિન્ટ-ગુણવત્તાવાળા PDF તરીકે ડાઉનલોડ કરવા માટે Export નો ઉપયોગ કરો, જે નિયોન ડિઝાઇન સિસ્ટમ સાથે સ્ટાઇલ કરેલ હોય છે.
દરેક સ્પેસમાં પ્રતિ-પૂછપરછ બજેટ હોય છે: પ્રોબ્સની મહત્તમ સંખ્યા, તપાસ રાઉન્ડ, સેકન્ડ અને USD. એન્જિન મર્યાદા પર સ્વચ્છ રીતે અટકે છે અને અત્યાર સુધી તેને શું મળ્યું તે જાણ કરે છે. દરેક પ્રોબનો ખર્ચ રસીદ પર વિગતવાર દર્શાવવામાં આવે છે, જેથી તમને હંમેશા ખબર પડે કે ખર્ચ ક્યાં થયો.
/v1/discovery/* હેઠળ
discovery સ્કોપ ધરાવતા PAT સાથે ઉપલબ્ધ છે (તેને Account → API Tokens હેઠળ બનાવો).
સ્ટ્રીમિંગ પૂછપરછ SSE નો ઉપયોગ કરે છે. બાહ્ય એક્ઝિક્યુટર્સ Thinking API (/v1/think/*, સ્કોપ think)
દ્વારા ફક્ત તપાસ આયોજન ઉધાર લઈ શકે છે.pip install deepcerebra-discovery, પછી
DiscoveryClient(base_url, token).ask(space_id, question).discovery.ask) ને પાઇપલાઇન સ્ટેપ તરીકે તપાસ ચલાવવા માટે છોડો; જવાબ, ચાર્ટ્સ અને રસીદ
ડાઉનસ્ટ્રીમ સ્ટેજ પર પ્રવાહિત થાય છે.discovery_ask અને
discovery_list_spaces ને MCP ટૂલ્સ તરીકે ખુલ્લા પાડે છે, જેથી બાહ્ય MCP ક્લાયન્ટ્સ પણ તપાસ ચલાવી શકે.