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 స్కోప్ (క్లాసిక్) లేదా కంటెంట్స్ + పుల్ రిక్వెస్ట్లతో కూడిన ఫైన్-గ్రెయిన్డ్ టోకెన్ను ఉపయోగించండి; GitLab కోసం api స్కోప్ను ఉపయోగించండి. మీ టోకెన్ సర్వర్లో నిల్వ చేయబడుతుంది — ఫైల్ కంటెంట్లు మాత్రమే బ్రౌజర్లోకి లాగబడతాయి.owner/nameగా టైప్ చేయండి (మీది కనుగొనడానికి జాబితాను ఫిల్టర్ చేయండి), ఆపై ఒక branchని ఎంచుకోండి.dcc/my-feature)ని టిక్ చేయండి, మీ పనిని డిఫాల్ట్ బ్రాంచ్ నుండి వేరుగా ఉంచడానికి.చాట్ చరిత్ర తెరిచిన ప్రాజెక్ట్కు అనుసంధానించబడి ఉంటుంది. ఫోల్డర్లను మార్చడం స్వయంచాలకంగా కొత్త సెషన్ను ప్రారంభిస్తుంది మరియు ఆ ఫోల్డర్ యొక్క మునుపటి సెషన్లను లోడ్ చేస్తుంది, మీరు ఎక్కడ ఆపారో అక్కడి నుండి తిరిగి ప్రారంభించడానికి అత్యంత ఇటీవలిదాన్ని మళ్లీ తెరుస్తుంది.
DeepCerebra అంతర్గతంగా ఉపయోగించే ఫోల్డర్లు — .deepcerebra, .sessions — ట్రీలో కనిపిస్తాయి కానీ మీ సోర్స్ను చిందరవందర చేయకుండా ఉండటానికి డిఫాల్ట్గా కుదించబడతాయి.
మీరు ఏమి కోరుకుంటున్నారో సాధారణ భాషలో వివరించండి — ఒక ప్రశ్న అడగండి, ఒక ఫీచర్ను అభ్యర్థించండి లేదా ఒక బగ్ను సూచించండి. ఉత్తమ ఫలితం పొందడానికి ఫైల్లు, ఫ్రేమ్వర్క్లు మరియు పరిమితుల గురించి నిర్దిష్టంగా ఉండండి. సంబంధిత ఫైల్లను ప్రాంప్ట్లోకి లాగడం ద్వారా అటాచ్ చేయండి.
ప్రతిస్పందనలు కర్సర్ లాగా నిర్వహించబడతాయి: ఏజెంట్ యొక్క తార్కికం అందించదగినది నుండి వేరు చేయబడుతుంది. ప్రతి ప్రతిస్పందన బ్లాక్లో దాని కుడి ఎగువ మూలలో ఒక కాపీ చిహ్నం ఉంటుంది, తద్వారా మీరు పూర్తి చేసిన నివేదిక, పత్రం లేదా మీరు అమలు చేయాల్సిన ఆదేశాన్ని కాపీ చేయవచ్చు.
html.parser బదులుగా lxml ఉపయోగించండి").@deepcerebraతో చాట్లో ఏజెంట్ను పిలుస్తారు, మరియు [deep] వంటి ప్రిఫిక్స్లు లోతైన తార్కికాన్ని అభ్యర్థిస్తాయి.ప్రాంప్ట్ పక్కన ఉన్న మోడ్ సెలెక్టర్లో ఒక మోడ్ను ఎంచుకోండి. ప్రతి మోడ్ ఏజెంట్ ఎంత ప్రణాళికలు వేస్తుంది మరియు ఎంత స్వేచ్ఛగా ఎడిట్ చేస్తుంది అనే దానిని ట్యూన్ చేస్తుంది:
| మోడ్ | ఇది ఏమి చేస్తుంది | ఎప్పుడు ఉపయోగించాలి… |
|---|---|---|
| Agent | మీ ప్రాజెక్ట్ అంతటా స్వయంప్రతిపత్తిగా ప్రణాళికలు వేస్తుంది మరియు ఎడిట్ చేస్తుంది | అసిస్టెంట్ మార్పును ఎండ్-టు-ఎండ్ అమలు చేయాలని మీరు కోరుకున్నప్పుడు |
| Ask | ఎడిట్ చేయకుండా మీ కోడ్ గురించి ప్రశ్నలకు సమాధానం ఇస్తుంది | మీరు కోడ్బేస్ను అర్థం చేసుకోవాలనుకున్నప్పుడు |
| Plan | ఏదైనా ఎడిటింగ్ చేయడానికి ముందు ఒక విధానాన్ని డ్రాఫ్ట్ చేస్తుంది | పని పెద్దది లేదా ముందుగా పరిష్కరించాల్సిన రాజీలు ఉన్నాయి |
| Edit | ప్రస్తుత సందర్భంలో కేంద్రీకృత ఎడిట్లను చేస్తుంది | మీరు చిన్న, లక్ష్య మార్పును కోరుకున్నప్పుడు |
ఏజెంట్ ఫైల్ మార్పులను ప్రతిపాదించినప్పుడు, చాట్ ఇన్పుట్ పైన ఒక ప్రతిపాదిత మార్పులు ప్యానెల్ కనిపిస్తుంది, ప్రతి మార్చబడిన ఫైల్ను జోడించిన (+) మరియు తీసివేసిన (−) లైన్ కౌంట్లతో జాబితా చేస్తుంది.
appliedగా గుర్తించబడతాయి (మరియు నిజమైన ఫోల్డర్కు వ్రాసినప్పుడు · disk).బిల్డ్లు, టెస్ట్లు మరియు స్క్రిప్ట్లను రన్ చేయడానికి ఎడిటర్ కింద ఉన్న టెర్మినల్ను టోగుల్ చేయండి. మీ అనుమతితో, ఏజెంట్ ఆదేశాలను అమలు చేయగలదు మరియు దాని పనిని ధృవీకరించడానికి వాటి అవుట్పుట్ను చదవగలదు; ఎక్కువసేపు నడిచే ఆదేశాలు అవుట్పుట్ను స్ట్రీమ్ చేస్తాయి, తద్వారా మీరు పురోగతిని చూడవచ్చు. మీకు అవసరం లేనప్పుడు టెర్మినల్ను దాని హెడర్ నుండి మూసివేయండి.
పెద్ద లక్ష్యాల కోసం, Plan మోడ్ను ఉపయోగించండి (లేదా ఏజెంట్ను మొదట ప్లాన్ చేయమని అడగండి). ప్లానర్ మీ ప్రాజెక్ట్ను స్కాన్ చేస్తుంది, లక్ష్యాన్ని డిపెండెన్సీ-అవేర్ టాస్క్లుగా విడగొడుతుంది మరియు ప్రతి దానిని సరైన నిపుణుడికి (ఆర్కిటెక్ట్, కోడర్, టెస్టర్, డాక్స్) కేటాయిస్తుంది.
ప్రాంప్ట్ పక్కన ఉన్న మోడల్ పికర్ను తెరవండి. ఎంపికలు ఇలా సమూహపరచబడతాయి:
ఆటోలో, 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అప్పుడు టెర్మినల్ ప్యానెల్ను తెరవండి, ఎగ్జిక్యూషన్ టార్గెట్ పాప్ఓవర్ను (ల్యాప్టాప్ చిహ్నం) క్లిక్ చేయండి, నా కంప్యూటర్ను ఎంచుకోండి, మరియు ఒక వర్కింగ్ డైరెక్టరీని ఎంచుకోండి. మీరు టైప్ చేసిన ఆదేశాలు మరియు ఏజెంట్ యొక్క బిల్డ్/టెస్ట్ ఆదేశాలు రెండూ మీ మెషీన్లో అమలు చేయబడతాయి.
--no-exec ఒక పరికరాన్ని ఇన్ఫరెన్స్-మాత్రమే చేస్తుంది (GPU మోడల్లు, ఆదేశాలు లేవు).Git-ఆధారిత ప్రాజెక్ట్ తెరిచి ఉన్నప్పుడు, Explorerలో మీ ప్రస్తుత బ్రాంచ్ను మరియు రెండు చర్యలను చూపుతూ ఒక బ్రాంచ్ బార్ కనిపిస్తుంది:
main) పుల్ రిక్వెస్ట్ను తెరవండి. మీరు డిఫాల్ట్ బ్రాంచ్లో కాకుండా వర్కింగ్ బ్రాంచ్లో ఉండాలి.పుష్ వెబ్హుక్ ప్రారంభించబడితే, సహోద్యోగులు పుష్ చేసినప్పుడు 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 వనరులు లేదా ప్రాంప్ట్ టెంప్లేట్లను బహిర్గతం చేస్తే, ఏజెంట్ వాటిని ఉపయోగించడానికి స్వయంచాలకంగా టూల్స్ను పొందుతుంది (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` లలో ఒకే విధంగా పనిచేస్తుంది. వెబ్ యాప్లో, వీటినన్నింటినీ `ఏజెంట్` వీక్షణ కింద నిర్వహించండి; డెస్క్టాప్లో మరియు API ద్వారా అవి మీ ప్రాజెక్ట్తో మీరు కట్టుబడి ఉండే సాధారణ ఫైల్లు.
కాన్ఫిగరేషన్ అనేక స్కోప్ల నుండి కనుగొనబడుతుంది; ఒకే అంశం ఒకటి కంటే ఎక్కువ వాటిలో ఉన్నప్పుడు, అధిక-ప్రాధాన్యత గలది గెలుస్తుంది:
team/org < global (~/.deepcerebra) < workspace (<repo>/.deepcerebra)
(lowest) (highest)<repo>/.deepcerebra/…, ప్రాజెక్ట్తో కట్టుబడి ఉంటుంది.~/.deepcerebra/…, ప్రాజెక్ట్ల అంతటా మీ వ్యక్తిగత డిఫాల్ట్లు.నియమాలు నిరంతర సూచనలు — కోడింగ్ ప్రమాణాలు, ఆర్కిటెక్చర్ సంప్రదాయాలు, డొమైన్ సందర్భం — ఏజెంట్ సిస్టమ్ ప్రాంప్ట్లోకి ఇంజెక్ట్ చేయబడతాయి. అవి .deepcerebra/steering/ కింద మార్క్డౌన్ ఫైల్లుగా ఉంటాయి, అలాగే ఎల్లప్పుడూ ఆన్లో ఉండే 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.ఏజెంట్ తేలికపాటి కేటలాగ్ను (name + description) చూస్తుంది మరియు సంబంధితంగా ఉన్నప్పుడు 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 హుక్ అది అడ్డగించే టూల్ కాల్ను allow, deny లేదా ask చేయగలదు.
సబ్ఏజెంట్లు మీరు నిర్వచించి, అప్పగించే నిపుణులైన ఏజెంట్లు. ప్రతి ఒక్కటి .deepcerebra/agents/ కింద ఫ్రంట్మేటర్ ప్లస్ ఒక బాడీ (దాని సిస్టమ్ ప్రాంప్ట్)తో కూడిన మార్క్డౌన్ ఫైల్:
---
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 అనేది బహుళ-ఏజెంట్ ఆటోమేషన్ కోసం ఒక విజువల్ డిజైనర్. మీరు దశలను — ప్రతి ఒక్కటి ఒక ఏజెంట్, ఒక నిపుణులైన దశ, లేదా ఒక నియంత్రణ ప్రిమిటివ్ — ఒక గ్రాఫ్గా కంపోజ్ చేస్తారు, వాటిని డిపెండెన్సీలతో కలుపుతారు మరియు లైవ్ పర్-స్టేజ్ పురోగతి, బడ్జెట్లు మరియు మానవ-ఆమోదం గేట్లతో మొత్తం ఆర్కెస్ట్రేషన్ను ఇంజిన్పై అమలు చేస్తారు. వర్క్ఫ్లోలు మీరు Gitలో ఎగుమతి చేయగల, దిగుమతి చేయగల, వెర్షన్ చేయగల మరియు API లేదా CLI నుండి అమలు చేయగల పోర్టబుల్ YAML/JSON నిర్వచనంగా సేవ్ చేయబడతాయి.
| స్టేజ్ రకం | ఇది ఏమి చేస్తుంది |
|---|---|
agent | మీరు అటాచ్ చేసే నైపుణ్యాలు మరియు టూల్స్తో ఒక ఏజెంట్ మలుపు. |
spec.requirements / spec.design / spec.execute |
స్పెక్-ఫస్ట్ డెలివరీ: డ్రాఫ్ట్ అవసరాలు, డిజైన్, ఆపై టాస్క్లుగా విడగొట్టి అమలు చేయండి — ప్రతి ఒక్కటి గేటబుల్. |
documents.generate | మునుపటి దశ అవుట్పుట్ల నుండి ఒక మెరుగుపరచబడిన పత్రాన్ని తయారు చేయండి. |
fan_out | అనేక సబ్టాపిక్లలో సింథసిస్తో సమాంతర విస్తృత-పరిశోధన. |
map / loop / switch |
నియంత్రణ ప్రిమిటివ్లు: ప్రతి అంశానికి ఒక బాడీని అమలు చేయండి, ఒక షరతు వరకు పునరావృతం చేయండి, లేదా కేసుల అంతటా బ్రాంచ్ చేయండి. |
verify / browser_verify |
పరీక్షలను లేదా ఆదేశాలను శాండ్బాక్స్లో అమలు చేయండి; బ్రౌజర్ ఆటోమేషన్తో నడుస్తున్న UIని ధృవీకరించండి. |
orchestrate | డైనమిక్ రూటింగ్: ఒక ఆర్కెస్ట్రేటర్ ఏజెంట్ అభ్యర్థనను చదివి, ఈవెంట్ల ద్వారా ఉత్తమ డౌన్స్ట్రీమ్ ఏజెంట్(ల)కు పంపుతుంది. |
external.agent | నమోదు చేయబడిన మూడవ పక్ష ఏజెంట్ను HTTP (A2A) ద్వారా స్థానిక దశ వలె పిలవండి. |
eval | అప్స్ట్రీమ్ అవుట్పుట్ను తనిఖీలకు వ్యతిరేకంగా స్కోర్ చేయండి (కలిగి ఉంది / రెగ్యులర్ ఎక్స్ప్రెషన్ / పొడవు / 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 మానిఫెస్ట్లు, లేదా ఒక Helm చార్ట్ — మీరు స్వంతం చేసుకుని కమిట్ చేసే ఫైల్లు. |
test.generate | నిర్మించిన యాప్ కోసం యూనిట్ / API / E2E సూట్లను ప్లస్ ఒక అవసరం-నుండి-పరీక్ష ట్రేసబిలిటీ మ్యాట్రిక్స్ను ఉత్పత్తి చేయండి. |
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: బ్లాక్ స్టూడియో మూసివేయబడినప్పుడు కూడా ఇన్బౌండ్ వెబ్హుక్స్, క్రాన్ షెడ్యూల్లు, ఈవెంట్లు లేదా చాట్పై ప్రారంభించడానికి దానిని సిద్ధం చేస్తుంది.ఈవెంట్లకు ప్రతిస్పందించే ఏజెంట్లు ఒక స్థిరమైన పేరున్న క్యూని ప్రకటించగలరు, తద్వారా ఏజెంట్ బిజీగా ఉన్నప్పుడు లేదా ఒక రన్ వినడానికి ముందు సరిపోలే ఈవెంట్లు ఎప్పటికీ కోల్పోవు. ట్రిగ్గర్ సబ్స్క్రిప్షన్లో, 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 దానిని మ్యూటెక్స్గా చేస్తుంది: ఒకేసారి ఒక టాస్క్ మాత్రమే (వర్క్స్పేస్లోని అన్ని సమాంతర రన్లలో) క్లిష్టమైన దశను అమలు చేస్తుంది; ఇతర ప్రతి టాస్క్ హోల్డర్ పూర్తయ్యే వరకు వేచి ఉంటుంది.
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 — రెండెజ్వస్: ప్రతి ట్రిగ్గర్ సబ్స్క్రిప్షన్ (ప్రతి దాని స్వంత టాపిక్, క్లాస్ ఫిల్టర్ మరియు ఐచ్ఛిక 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 వినియోగం |
|---|---|---|
| Basic | $20 | $10 |
| Pro | $75 | $30 |
| Ultimate | $200 | $150 |
ఒక గేట్వే API కీ (వ్యక్తిగత యాక్సెస్ టోకెన్) DeepCerebra పబ్లిక్ API మరియు CLIని ప్రోగ్రామాటిక్గా ఉపయోగించడానికి మిమ్మల్ని అనుమతిస్తుంది.
read, chat, code, agent — మరియు రోజులలో ఐచ్ఛిక expiryని ఎంచుకోండి (ఖాళీ = ఎప్పుడూ కాదు).దీనిని 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) చేయవచ్చు; ప్రతి కీ దాని ప్రిఫిక్స్, స్కోప్లు, సృష్టించిన/గడువు ముగిసిన తేదీ మరియు చివరిగా ఉపయోగించిన తేదీని చూపుతుంది.
Chrome, Edge, లేదా Braveకు మారండి, లేదా బదులుగా Open from Gitని ఉపయోగించండి.
Stop క్లిక్ చేయండి, ఆపై ఒక నిర్దిష్ట సూచన లేదా పరిమితితో తిరిగి వ్రాయండి.
dcc-bridge కనెక్టర్ నడుస్తుందని మరియు పరికరం ఆన్లైన్లో ఉందని నిర్ధారించుకోండి.1234) ఒక మోడల్తో లోడ్ చేయబడిందని నిర్ధారించుకోండి.--gateway గా ఉపయోగించండి
(wss://deepcerebra.ai లేదా wss://deepcerebra.io) — ఈ రెండు సైట్లు వేర్వేరు
డిప్లాయ్మెంట్లు, మరియు ఒకదాని నుండి వచ్చిన టోకెన్ మరొకదానిపై ఎప్పటికీ పనిచేయదు.పుల్ రిక్వెస్ట్ను తెరవడానికి Integrateని ఉపయోగించే ముందు వర్కింగ్ బ్రాంచ్ను తెరవండి లేదా సృష్టించండి.
ఇంకా చిక్కుకున్నారా? support@deepcerebra.aiని సంప్రదించండి.
Discovery అనేది మీ డేటాబేస్లు మరియు డాక్యుమెంట్ల కోసం ఒక పరిశోధనాత్మక చాట్బాట్.
ఒకే ప్రశ్నతో సమాధానం చెప్పడానికి బదులుగా, ఇది ఒక విశ్లేషకుడిలా పనిచేస్తుంది: ఇది పరికల్పనలను రూపొందిస్తుంది,
రక్షిత ప్రోబ్ల శ్రేణిని (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 క్లయింట్లు కూడా
పరిశోధనలను అమలు చేయగలరు.