DeepCerebra Coder არის აგენტური კოდირების ასისტენტი. ჩვეულებრივი ავტომატური შევსების კოპილოტისგან განსხვავებით, ის გეგმავს, წერს, რეფაქტორინგს უკეთებს, ასრულებს ბრძანებებს, იძახებს ხელსაწყოებს და იმეორებს მოქმედებებს თქვენს მთელ პროექტზე — თქვენ განიხილავთ და ამტკიცებთ მის მიერ შემოთავაზებულ ცვლილებებს.
| გამოცემა | საუკეთესოა | ფაილზე წვდომა |
|---|---|---|
| ვებ აპლიკაცია | ინსტალაციის გარეშე, იმუშავეთ ნებისმიერი მანქანიდან | კონფიდენციალური ბრაუზერში შენახვა (და Git რეპოზიტორები) |
| დესკტოპი (Windows / Linux / macOS) | ლოკალური განვითარება, ლოკალური მოდელები | პირდაპირი ლოკალური ფაილური სისტემა |
| CLI & API | სკრიპტინგი, CI/CD, ავტომატიზაცია | ლოკალური ფაილები / პროგრამული |
ეს სახელმძღვანელო ფოკუსირებულია ვებ აპლიკაციაზე deepcerebra.ai; დესკტოპის აპლიკაცია ასახავს იგივე პანელებსა და სამუშაო პროცესებს.
გამოიყენეთ მიმდინარე ვერსია Chrome, Edge, or Brave სრული გამოცდილებისთვის — ლოკალური საქაღალდის გახსნა ეყრდნობა Chromium File System Access API-ს. Firefox და Safari მუშაობს ჩატისთვის და Git-ზე დაფუძნებული პროექტებისთვის, მაგრამ ვერ ხსნის ლოკალურ საქაღალდეს პირდაპირ.
/register?plan=basic (ან pro / ultimate), ან დაიწყეთ ახლა და აირჩიეთ გეგმა
მოგვიანებით ბილინგი-ში.შესვლის შემდეგ თქვენ აღმოჩნდებით სამუშაო სივრცეში, რომელიც ყველა პანელს ერთ ეკრანზე ათავსებს:
გადაათრიეთ გამყოფი რედაქტორსა და ჩატს შორის განლაგების დასაბალანსებლად, და გადაათრიეთ ჰორიზონტალური გამყოფი ტერმინალის ზომის შესაცვლელად. მარცხენა გვერდითი ზოლი ასევე გადადის სამუშაო სივრცეში, გაფართოებებში, API გასაღებებში, ბილინგში და უკუკავშირში.
repo არე (კლასიკური) ან დეტალური ნიშანი Contents + Pull requests-ით;
GitLab-ისთვის გამოიყენეთ api არე. თქვენი ნიშანი ინახება სერვერზე — ბრაუზერში მხოლოდ ფაილის შიგთავსი იტვირთება.owner/name (გაფილტრეთ სია თქვენის საპოვნელად), შემდეგ აირჩიეთ ფილიალი.dcc/my-feature) თქვენი სამუშაოს ნაგულისხმევი ფილიალისგან იზოლირებულად შესანარჩუნებლად.ჩეთის ისტორია დაკავშირებულია ღია პროექტთან. საქაღალდეების შეცვლა ავტომატურად იწყებს ახალ სესიას და ტვირთავს ამ საქაღალდის წინა სესიებს, ხელახლა ხსნის უახლესს, რათა შეძლოთ გაგრძელება იქიდან, სადაც შეჩერდით.
DeepCerebra-ს მიერ შიდა გამოყენებისთვის განკუთვნილი საქაღალდეები — .deepcerebra, .sessions — გამოჩნდება ხეში, მაგრამ ნაგულისხმევად ჩაკეცილია, რათა არ დააბინძუროს თქვენი წყარო.
აღწერეთ, რა გსურთ მარტივი ენით — დასვით შეკითხვა, მოითხოვეთ ფუნქცია, ან მიუთითეთ შეცდომაზე. იყავით კონკრეტული ფაილების, ფრეიმვორკების და შეზღუდვების შესახებ საუკეთესო შედეგის მისაღებად. დაურთეთ შესაბამისი ფაილები მათი მოთხოვნაში გადათრევით.
პასუხები ორგანიზებულია Cursor-ის მსგავსად: აგენტის მსჯელობა გამოყოფილია შესრულებადი ნაწილისგან. თითოეულ საპასუხო ბლოკს აქვს კოპირების ხატულა ზედა მარჯვენა კუთხეში, რათა შეძლოთ დასრულებული ანგარიშის, დოკუმენტის ან ბრძანების კოპირება, რომელიც უნდა გაუშვათ.
lxml html.parser-ის ნაცვლად") აგენტის ციკლიდან გამოსაყვანად.@deepcerebra-ით, და პრეფიქსები, როგორიცაა [deep], ითხოვენ უფრო ღრმა მსჯელობას.აირჩიეთ რეჟიმი რეჟიმის ამომრჩევიდან მოთხოვნის გვერდით. თითოეული არეგულირებს, თუ რამდენად გეგმავს აგენტი და რამდენად თავისუფლად რედაქტირებს:
| რეჟიმი | რას აკეთებს | გამოიყენეთ როდესაც… |
|---|---|---|
| აგენტი | გეგმავს და რედაქტირებს თქვენს პროექტში ავტონომიურად | გსურთ, რომ ასისტენტმა განახორციელოს ცვლილება ბოლოდან ბოლომდე |
| კითხვა | პასუხობს შეკითხვებს თქვენი კოდის შესახებ რედაქტირების გარეშე | გსურთ კოდის ბაზის გაგება |
| დაგეგმვა | ქმნის მიდგომას ნებისმიერი რედაქტირებამდე | ამოცანა დიდია ან აქვს კომპრომისები, რომლებიც ჯერ უნდა გადაწყდეს |
| რედაქტირება | ახორციელებს მიზანმიმართულ რედაქტირებას მიმდინარე კონტექსტში | გსურთ მცირე, მიზანმიმართული ცვლილება |
როდესაც აგენტი ფაილის ცვლილებებს გვთავაზობს, ჩეთის შეყვანის ზემოთ ჩნდება პანელი შემოთავაზებული ცვლილებები, რომელიც ჩამოთვლის თითოეულ შეცვლილ ფაილს დამატებული (+) და წაშლილი (−) ხაზების რაოდენობით.
applied (და · disk, როდესაც ჩაწერილია რეალურ საქაღალდეში).გადართეთ ტერმინალი რედაქტორის ქვემოთ, რათა გაუშვათ build-ები, ტესტები და სკრიპტები. თქვენი ავტორიზაციით, აგენტს შეუძლია ბრძანებების შესრულება და მათი გამოსავლის წაკითხვა თავისი მუშაობის გადასამოწმებლად; ხანგრძლივი ბრძანებები გამოსავალს ნაკადად აჩვენებენ, რათა თვალყური ადევნოთ პროგრესს. დახურეთ ტერმინალი მისი სათაურიდან, როცა აღარ გჭირდებათ.
უფრო დიდი მიზნებისთვის გამოიყენეთ დაგეგმვის რეჟიმი (ან სთხოვეთ აგენტს, ჯერ დაგეგმოს). დამგეგმავი სკანირებს თქვენს პროექტს, მიზანს ყოფს დამოკიდებულებების გათვალისწინებით ამოცანებად და თითოეულს შესაბამის სპეციალისტს (არქიტექტორს, პროგრამისტს, ტესტერს, დოკუმენტაციის სპეციალისტს) უნიშნავს.
გახსენით მოდელის ამომრჩევი მოთხოვნის გვერდით. პარამეტრები დაჯგუფებულია შემდეგნაირად:
ავტომატურ რეჟიმში, DeepCerebra იყენებს მრავალდონიან, ადაპტირებულ მარშრუტიზაციას: მარტივი ამოცანები მიდის სწრაფ, ეკონომიურ მოდელზე, ხოლო რთული ან დაგეგმვაზე ორიენტირებული სამუშაო (მაგალითად, დაგეგმვის რეჟიმი) მიმართულია უფრო ძლიერ მოდელზე. ეს ავტომატურად აბალანსებს ღირებულებასა და ხარისხს, ასე რომ იშვიათად გჭირდებათ ხელით არჩევა.
თქვენ შეგიძლიათ მოთხოვნების მარშრუტიზაცია თქვენი საკუთარი პროვაიდერის ანგარიშის მეშვეობით, პლატფორმის გაზომილი გამოყენების ნაცვლად.
ANTHROPIC_API_KEY, GOOGLE_API_KEY, OPENAI_API_KEY).პლატფორმის (DeepCerebra) მოდელებს გასაღები არ სჭირდებათ. გასაღების წაშლა ნებისმიერ დროს შეგიძლიათ ღილაკით წაშლა.
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 or 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შემდეგ გახსენით ტერმინალის პანელი, დააწკაპუნეთ შესრულების სამიზნე popover-ზე (ლეპტოპის ხატულა), აირჩიეთ ჩემი კომპიუტერი და აირჩიეთ სამუშაო დირექტორია. ამის შემდეგ თქვენი აკრეფილი ბრძანებები და აგენტის build/test ბრძანებები შესრულდება თქვენს მანქანაზე.
--no-exec ხდის მოწყობილობას მხოლოდ ინფერენციულს (GPU მოდელები, ბრძანებების გარეშე).Git-ზე დაფუძნებული პროექტის გახსნისას, Explorer-ში ჩნდება ფილიალის ზოლი, რომელიც აჩვენებს თქვენს მიმდინარე ფილიალს და ორ მოქმედებას:
main). თქვენ უნდა იყოთ სამუშაო ფილიალზე და არა ნაგულისხმევ ფილიალზე.თუ push webhook ჩართულია, Explorer ავტომატურად განახლდება, როდესაც თანაგუნდელები push-ს გააკეთებენ, რაც ყველას სინქრონულად ინარჩუნებს — ეს არის 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/…, თქვენი პირადი ნაგულისხმევი პარამეტრები პროექტებში.წესები არის მუდმივი ინსტრუქციები — კოდირების სტანდარტები, არქიტექტურული კონვენციები, დომენის კონტექსტი — რომლებიც შეყვანილია აგენტის სისტემურ მოთხოვნაში. ისინი ცხოვრობენ Markdown ფაილებად .deepcerebra/steering/-ის ქვეშ, პლუს ყოველთვის ჩართული 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) ვრცელდება მხოლოდ ამ საქაღალდის ქვეშ არსებულ ფაილებზე. ვებ აპლიკაციაში, აგენტი → Steering ხედი თითოეულ წესს აძლევს სკოპის ამომრჩეველს (გლობალური / პროექტი / გუნდი).
უნარები არის მრავალჯერადი გამოყენების playbooks, რომლებსაც აგენტი ტვირთავს მოთხოვნისამებრ. თითოეული უნარი არის საქაღალდე SKILL.md-ით .deepcerebra/skills/-ის ქვეშ:
---
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 ინტეგრირებული ხელსაწყოს გამოძახებისთვის.
სუბაგენტები არიან სპეციალისტი აგენტები, რომლებსაც თქვენ განსაზღვრავთ და დელეგირებთ. თითოეული არის Markdown ფაილი .deepcerebra/agents/-ის ქვეშ frontmatter-ით პლუს შიგთავსით (მისი სისტემური მოთხოვნა):
---
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 (fan-out) გამოყენებით.
დანამატი აერთიანებს წესებს, უნარებს, ჰუკებს, სუბაგენტებს და 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 დირექტორიაზე მითითებით, ან ვებ აპლიკაციაში წესების გუნდის სკოპზე დაყენებით.Workflow Studio არის ვიზუალური დიზაინერი მრავალაგენტური ავტომატიზაციისთვის. თქვენ აკომპონირებთ სტადიებს — თითოეული აგენტი, სპეციალისტის ნაბიჯი ან კონტროლის პრიმიტივი — გრაფაში, აკავშირებთ მათ დამოკიდებულებებით და აწარმოებთ მთელ ორკესტრაციას ძრავზე ცოცხალი სტადიის პროგრესით, ბიუჯეტებით და ადამიანის დამტკიცების კარიბჭეებით. სამუშაო პროცესები ინახება როგორც პორტატული YAML/JSON განმარტება, რომლის ექსპორტი, იმპორტი, ვერსიონირება Git-ში და გაშვება შესაძლებელია API-დან ან CLI-დან.
| სტადიის სახეობა | რას აკეთებს |
|---|---|
agent | ერთი აგენტის მოქმედება თქვენს მიერ მიმაგრებული უნარებითა და ხელსაწყოებით. |
spec.requirements / spec.design / spec.execute |
სპეციფიკაციაზე ორიენტირებული მიწოდება: მოთხოვნების, დიზაინის შემუშავება, შემდეგ ამოცანებად დაყოფა და შესრულება — თითოეული კარიბჭით. |
documents.generate | წინა სტადიის გამომავალი ინფორმაციის საფუძველზე დახვეწილი დოკუმენტის შექმნა. |
fan_out | პარალელური ფართო კვლევა მრავალ ქვე-თემაზე სინთეზით. |
map / loop / switch |
კონტროლის პრიმიტივები: სხეულის გაშვება თითოეული ელემენტისთვის, გამეორება პირობის შესრულებამდე, ან განშტოება შემთხვევების მიხედვით. |
verify / browser_verify |
ტესტების ან ბრძანებების გაშვება sandbox-ში; გაშვებული UI-ის გადამოწმება ბრაუზერის ავტომატიზაციით. |
orchestrate | დინამიური მარშრუტიზაცია: ორკესტრატორის აგენტი კითხულობს მოთხოვნას და აგზავნის მას საუკეთესო ქვედა დინების აგენტ(ებ)თან მოვლენების მეშვეობით. |
external.agent | დარეგისტრირებული მესამე მხარის აგენტის გამოძახება HTTP-ის (A2A) მეშვეობით, თითქოს ის მშობლიური სტადია იყოს. |
eval | ზედა დინების გამომავალი ინფორმაციის შეფასება შემოწმებების მიხედვით (შეიცავს / regex / სიგრძე / LLM-judge); ჩავარდნა ზღვარს ქვემოთ. |
db.provision | შექმენით საკუთარი მონაცემთა ფენა: docker-compose მონაცემთა ბაზისთვის,
ვერსიული SQL მიგრაციები, საწყისი მონაცემები, .env თარგი და Mermaid ERD; სურვილისამებრ ავთენტიფიკაციის კარკასი;
შეუძლია მიგრაციების დაუყოვნებლივ გამოყენება SQLite-ზე. |
ci.generate | მზა CI/CD კონვეიერის (GitHub Actions, GitLab CI, ან Azure Pipelines) გენერაცია lint → test → scan → build → deploy და გარემოს პრომოციით. |
deploy.package | საწარმოო განლაგების აქტივების გენერაცია: მრავალსაფეხურიანი Dockerfile, docker-compose, Kubernetes მანიფესტები, ან Helm chart — ფაილები, რომლებიც თქვენ გეკუთვნით და აკომიტებთ. |
test.generate | ერთეულის / API / E2E კომპლექტების გენერაცია აგებული აპლიკაციისთვის პლუს მოთხოვნა-ტესტზე მიკვლევადობის მატრიცა. |
test.verify | ტესტების კომპლექტის შესრულება (pytest, vitest, jest, Playwright) და გაშვების შეზღუდვა მისი გავლის სიჩქარით. |
security.audit | დაასკანირეთ დამოკიდებულებები ცნობილი მოწყვლადობებისთვის და ხეში ჩამონტაჟებული საიდუმლოებებისთვის; გამოაქვეყნებს გაფრთხილების მოვლენებს და წერს აღმოჩენების ანგარიშს. |
preview | გენერირებული აპლიკაციის ლოკალურად გაშვება და მისი ცოცხალი URL-ის ჩვენება გაშვების პანელში (ბმული + inline frame) preview.ready მოვლენის მეშვეობით. |
design.import | UI დიზაინის სურათის (ეკრანის ანაბეჭდი, მაკეტი, Figma ექსპორტი) გადაქცევა სტრუქტურირებულ იმპლემენტაციის სპეციფიკაციად ქვედა დინების სტადიებისთვის. |
ყველა სტადიას — სახეობის მიუხედავად — შეუძლია გამოაქვეყნოს და გამოიწეროს ტიპური მოვლენები სამუშაო სივრცის მოვლენების ავტობუსზე, ასე რომ აგენტები კოორდინირებენ, როგორც სერვისები შეტყობინებების ქსელზე და არა მხოლოდ DAG-ის მეშვეობით:
lifecycle, agent, business, data, system, schedule, chat, external, ან alert — ფილტრაციის შესაძლებლობით გამოწერებში და განმეორებით გაშვებაში.trigger (სტადია გაშვებულია, როდესაც შესაბამისი მოვლენა მოდის; გაშვება გაჩერებული სტადიებით რჩება რეზიდენტულად, როგორც მოსმენა), gate (მანქანური კარიბჭე დამტკიცებულია მოვლენით ადამიანის დაწკაპუნების ნაცვლად), და data (payload გაერთიანებულია სტადიის კონტექსტში).agent.<stage-id>.request გამოქვეყნებით.triggers: ბლოკი აიარაღებს მას დასაწყებად შემომავალ webhooks-ზე, cron schedules-ზე, events-ზე, ან chat-ზე — მაშინაც კი, როდესაც 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_idA სემაფორი ზღუდავს, თუ რამდენი დავალება შეიძლება ერთდროულად მუშაობდეს საერთო (დაცულ) რესურსზე:
მონაცემთა ბაზა, რომელშიც ხდება ჩაწერა, გლობალური ცვლადების საცავი, ფაილი ან სიჩქარით შეზღუდული გარე აგენტი. მიამაგრეთ ის ნებისმიერ ეტაპზე semaphore: — სანამ ეტაპის სამუშაო შესრულდება, ძრავა იღებს დასახელებული სამუშაო სივრცის სემაფორის ერთ ნებართვას; ნებართვა ყოველთვის თავისუფლდება შემდეგ, მაშინაც კი, თუ ეტაპი ვერ მოხერხდა.
permits: 1 აქცევს მას მიუტექსად: მხოლოდ ერთი დავალება ერთდროულად (სამუშაო სივრცეში ყველა პარალელური გაშვებისას) ასრულებს კრიტიკულ ნაბიჯს; ყველა სხვა დავალება ელოდება, სანამ მფლობელი დაასრულებს.
timeout_s-მდე ნებართვისთვის; თუ რესურსი რჩება სრულად დატვირთული, ეტაპი თვალსაჩინოდ ჩავარდება სამუდამოდ გაჭედვის ნაცვლად.ttl_s; თუ მფლობელი ავარიულად შეწყვეტს მუშაობას გათავისუფლების გარეშე, ნებართვა ავტომატურად იწურება, რათა რესურსი არასოდეს იყოს ჩაკეტილი.semaphore.<name>.waiting, .acquired და .released სისტემურ მოვლენებს; GET /api/workflow/semaphores აჩვენებს ტევადობას, მფლობელებს და ხელმისაწვდომ ნებართვებს.acquire_semaphore, release_semaphore, and
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რანდევუ ელოდება, სანამ მრავალი მოვლენის ყველა პირობა არ დაკმაყოფილდება და მხოლოდ ამის შემდეგ გაგრძელდება შემდეგი ნაბიჯი — „პირველი მოვლენა იმარჯვებს“ პრინციპის საპირისპიროდ. დააყენეთ join: all ეტაპის events: ბლოკში: ყოველი ტრიგერის გამოწერა უნდა დაკმაყოფილდეს, სანამ ეტაპი შესრულდება. შეუთავსეთ თითოეული გამოწერისთვის განკუთვნილ count: N-ს, როდესაც რამდენიმე აგენტმა (ან ერთმა აგენტმა რამდენიმე ანგარიშით) უნდა მოახდინოს დაფიქსირება — მაგალითად, დიზაინის დამტკიცება, ტესტირების დასრულება და უსაფრთხოების დადასტურება, სანამ გამოშვების ეტაპი შესრულდება.
join: any (ნაგულისხმევი) — ეტაპი გაეშვება, როდესაც პირველი ტრიგერის გამოწერა დაკმაყოფილდება.join: all — შეხვედრა: თითოეული ტრიგერის გამოწერა (თითოეული თავისი თემით, კლასის ფილტრით და სურვილისამებრ count) უნდა დაკმაყოფილდეს; მხოლოდ ამის შემდეგ ხდება ეტაპი გაშვებადი.trigger_events და ხელმისაწვდომია შაბლონებისთვის, როგორც inputs.events (მოვლენის ობიექტების სია payloads-ით).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 და
cloud-CLI განთავსება (Fly, Render, Railway, Vercel), ასევე სიმულაციისთვის უსაფრთხო.Class.method) მათემატიკის, სიგნალის დამუშავების, კონტროლის, სტატისტიკის და სხვა სფეროებში./v1 API ავლენს გაშვებებს, მოვლენებს, ტრიგერებს, შაბლონებს და გენერაციას CI-სა და ინტეგრაციებისთვის.db.provision → იმპლემენტაციას → გენერირებულ ტესტებს → უსაფრთხოების აუდიტს → განლაგების შეფუთვას → CI გენერაციას, ადამიანის კარიბჭით შეფუთვამდე — სრული გზა მოკლე აღწერიდან წარმოებამდე, რომლის ადაპტირებაც წუთებში შეგიძლიათ.პროგნოზირებადი Tab შევსება გთავაზობთ inline, შუა ნაწილის შევსების კოდის შემოთავაზებებს რედაქტორში აკრეფისას — მიიღეთ შემოთავაზება Tab-ით. ის არის opt-in როგორც ძრავზე, ასევე ვებ რედაქტორზე.
DCC_TAB_COMPLETE=1. რედაქტორი იძახებს ძრავის POST /api/complete endpoint-ს, რომელიც აბრუნებს მხოლოდ ტექსტს კურსორთან ჩასასმელად.VITE_TAB_COMPLETE=1-ით, ან გაშვების დროს localStorage.setItem('dcc.tabComplete', '1')-ით (შემდეგ გადატვირთეთ).გახსენით ბილინგი გვერდითი ზოლიდან თქვენი გეგმისა და გამოყენების სამართავად. AI გამოყენება იზომება აშშ დოლარის კრედიტებში, რომელიც ეფუძნება ძირითადი მოდელების მიერ მოხმარებულ ტოკენებს.
| გეგმა | ყოველთვიური ფასი | ჩართული ყოველთვიური AI გამოყენება |
|---|---|---|
| Basic | $20 | $10 |
| Pro | $75 | $30 |
| Ultimate | $200 | $150 |
gateway API გასაღები (პირადი წვდომის ტოკენი) საშუალებას გაძლევთ გამოიყენოთ DeepCerebra საჯარო API და CLI პროგრამულად.
read, chat, code, agent — და არჩევითი ვადის გასვლის თარიღი დღეებში (ცარიელი = არასოდეს).გამოიყენეთ ის CLI-თან ან API-თან ერთად deepcerebra.ai-ზე:
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-ზე, ან გამოიყენეთ გახსნა Git-დან.
დააწკაპუნეთ შეჩერება, შემდეგ გადააფორმულირეთ კონკრეტული მინიშნებით ან შეზღუდვით.
dcc-bridge კონექტორი მუშაობს და მოწყობილობა აჩვენებს ონლაინ.1234) მოდელით დატვირთული.--gateway (wss://deepcerebra.ai ან wss://deepcerebra.io) — ეს ორი საიტი ცალკეული განლაგებაა და ერთი საიტიდან მიღებული ტოკენი არასოდეს იმუშავებს მეორეზე.გახსენით ან შექმენით სამუშაო ფილიალი ინტეგრირების გამოყენებამდე pull request-ის გასახსნელად.
კვლავ გაჭედილი ხართ? დაუკავშირდით support@deepcerebra.ai.
Discovery არის საგამოძიებო ჩატბოტი თქვენი მონაცემთა ბაზებისა და დოკუმენტებისთვის.
ერთი მოთხოვნით პასუხის გაცემის ნაცვლად, ის მუშაობს ანალიტიკოსივით: აყალიბებს ჰიპოთეზებს,
ატარებს დაცული გამოკვლევების სერიას (SQL, გრაფიკი, დოკუმენტების ძიება, სქემის შემოწმება, ვებ-დადასტურება), ჭრის
ახსნა-განმარტებებს, რომლებსაც მტკიცებულებები უარყოფს, და აყალიბებს დასაბუთებულ პასუხს — დიაგრამებითა და
გამჭვირვალე ხარჯების ქვითრით. გახსენით ის აქტივობის პანელზე არსებული კომპასის ხატულიდან
(/app/discovery).
სივრცე აერთიანებს ყველაფერს, რაც საჭიროა ერთი კითხვისთვის: მონაცემთა ბაზის კავშირები, დოკუმენტების კოლექციები, ინსტრუქციები ანალიტიკოსისთვის და ბიუჯეტები. შექმენით ერთი + ახალი სივრცე-ს გამოყენებით, შემდეგ გამოიყენეთ მარჯვენა მხარეს არსებული დაყენების პანელი, რათა:
აკრიფეთ შეკითხვა ისე, როგორც კოლეგას ჰკითხავდით — მაგალითად „რატომ შემცირდა MRI სკანირების მოცულობა მარტში?“. გამოძიების დაფა მთელ პროცესს პირდაპირ ეთერში აჩვენებს:
შემდგომი კითხვები აგრძელებს იმავე თემას, ასე რომ ანალიტიკოსი ინარჩუნებს კონტექსტს.
დიაგრამები გამოისახება პირდაპირ გამოძიების დაფაზე. გამოიყენეთ ექსპორტი სრული მოთხოვნის — პასუხის, ჰიპოთეზების, მტკიცებულებების და დიაგრამების — ჩამოსატვირთად, როგორც დამოუკიდებელი HTML ანგარიში ან ბეჭდვის ხარისხის PDF, ნეონის დიზაინის სისტემით სტილიზებული.
თითოეულ სივრცეს აქვს თითოეული მოთხოვნის ბიუჯეტი: გამოკვლევების მაქსიმალური რაოდენობა, გამოძიების რაუნდები, წამები და USD. ძრავა სუფთად ჩერდება ზღვარზე და აცნობებს, თუ რა იპოვა აქამდე. თითოეული გამოკვლევის ღირებულება დეტალურად არის მითითებული ქვითარზე, ასე რომ თქვენ ყოველთვის იცით, სად წავიდა დანახარჯი.
/v1/discovery/*-ის ქვეშ PAT-ით,
რომელსაც აქვს discovery არეალი (შექმენით ის ანგარიში → API ტოკენები-ს ქვეშ).
სტრიმინგის მოთხოვნები იყენებს 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 კლიენტებსაც შეუძლიათ გამოძიებების
ჩატარება.