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), ಅಥವಾ ಈಗಲೇ ಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ಯೋಜನೆಯನ್ನು
ನಂತರ ಬಿಲ್ಲಿಂಗ್ನಲ್ಲಿ ಆಯ್ಕೆ ಮಾಡಿ.ಸೈನ್ ಇನ್ ಮಾಡಿದ ನಂತರ ನೀವು ವರ್ಕ್ಬೆಂಚ್ಗೆ ಬರುತ್ತೀರಿ, ಅದು ಪ್ರತಿ ಪೇನ್ ಅನ್ನು ಒಂದೇ ಪರದೆಯಲ್ಲಿ ಇರಿಸುತ್ತದೆ:
ಲೇಔಟ್ ಅನ್ನು ಮರುಸಮತೋಲನಗೊಳಿಸಲು ಎಡಿಟರ್ ಮತ್ತು ಚಾಟ್ ನಡುವಿನ ಸ್ಪ್ಲಿಟರ್ ಅನ್ನು ಎಳೆಯಿರಿ, ಮತ್ತು ಟರ್ಮಿನಲ್ ಅನ್ನು ಮರುಗಾತ್ರಗೊಳಿಸಲು ಸಮತಲ ಸ್ಪ್ಲಿಟರ್ ಅನ್ನು ಎಳೆಯಿರಿ. ಎಡ ಸೈಡ್ಬಾರ್ ಕಾರ್ಯಕ್ಷೇತ್ರ, ವಿಸ್ತರಣೆಗಳು, API ಕೀಗಳು, ಬಿಲ್ಲಿಂಗ್, ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆ ಗೆ ಸಹ ನ್ಯಾವಿಗೇಟ್ ಮಾಡುತ್ತದೆ.
repo ಸ್ಕೋಪ್ (ಕ್ಲಾಸಿಕ್) ಅಥವಾ ವಿಷಯಗಳು + ಪುಲ್ ವಿನಂತಿಗಳೊಂದಿಗೆ ಉತ್ತಮ-ಧಾನ್ಯದ ಟೋಕನ್ ಬಳಸಿ; GitLab ಗಾಗಿ api ಸ್ಕೋಪ್ ಬಳಸಿ. ನಿಮ್ಮ ಟೋಕನ್ ಸರ್ವರ್ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ — ಫೈಲ್ ವಿಷಯಗಳನ್ನು ಮಾತ್ರ ಬ್ರೌಸರ್ಗೆ ಎಳೆಯಲಾಗುತ್ತದೆ.owner/name ಎಂದು ಟೈಪ್ ಮಾಡಿ (ನಿಮ್ಮದನ್ನು ಹುಡುಕಲು ಪಟ್ಟಿಯನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಿ), ನಂತರ ಬ್ರಾಂಚ್ ಆಯ್ಕೆಮಾಡಿ.dcc/my-feature) ನಿಮ್ಮ ಕೆಲಸವನ್ನು ಡೀಫಾಲ್ಟ್ ಬ್ರಾಂಚ್ನಿಂದ ಪ್ರತ್ಯೇಕವಾಗಿ ಇರಿಸಲು.ಚಾಟ್ ಇತಿಹಾಸವು ತೆರೆದ ಯೋಜನೆಗೆ ಸಂಬಂಧಿಸಿದೆ. ಫೋಲ್ಡರ್ಗಳನ್ನು ಬದಲಾಯಿಸುವುದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಹೊಸ ಸೆಷನ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ ಮತ್ತು ಆ ಫೋಲ್ಡರ್ನ ಹಿಂದಿನ ಸೆಷನ್ಗಳನ್ನು ಲೋಡ್ ಮಾಡುತ್ತದೆ, ನೀವು ಎಲ್ಲಿ ನಿಲ್ಲಿಸಿದ್ದೀರೋ ಅಲ್ಲಿಂದ ಮುಂದುವರಿಯಲು ಇತ್ತೀಚಿನದನ್ನು ಮರುತೆರೆಯುತ್ತದೆ.
DeepCerebra ಆಂತರಿಕವಾಗಿ ಬಳಸುವ ಫೋಲ್ಡರ್ಗಳು — .deepcerebra, .sessions — ಮರದಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ ಆದರೆ ನಿಮ್ಮ ಮೂಲವನ್ನು ಅಸ್ತವ್ಯಸ್ತಗೊಳಿಸದಂತೆ ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಕುಗ್ಗಿಸಲ್ಪಟ್ಟಿವೆ.
ನಿಮಗೆ ಬೇಕಾದುದನ್ನು ಸರಳ ಭಾಷೆಯಲ್ಲಿ ವಿವರಿಸಿ — ಪ್ರಶ್ನೆ ಕೇಳಿ, ವೈಶಿಷ್ಟ್ಯವನ್ನು ವಿನಂತಿಸಿ, ಅಥವಾ ದೋಷವನ್ನು ಸೂಚಿಸಿ. ಉತ್ತಮ ಫಲಿತಾಂಶವನ್ನು ಪಡೆಯಲು ಫೈಲ್ಗಳು, ಫ್ರೇಮ್ವರ್ಕ್ಗಳು ಮತ್ತು ನಿರ್ಬಂಧಗಳ ಬಗ್ಗೆ ನಿರ್ದಿಷ್ಟವಾಗಿರಿ. ಸಂಬಂಧಿತ ಫೈಲ್ಗಳನ್ನು ಪ್ರಾಂಪ್ಟ್ಗೆ ಎಳೆಯುವ ಮೂಲಕ ಲಗತ್ತಿಸಿ.
ಪ್ರತಿಕ್ರಿಯೆಗಳನ್ನು ಕರ್ಸರ್ನಂತೆ ಆಯೋಜಿಸಲಾಗಿದೆ: ಏಜೆಂಟ್ನ ತಾರ್ಕಿಕತೆಯನ್ನು ವಿತರಿಸಬಹುದಾದ ದಿಂದ ಪ್ರತ್ಯೇಕಿಸಲಾಗಿದೆ. ಪ್ರತಿ ಪ್ರತಿಕ್ರಿಯೆ ಬ್ಲಾಕ್ ಅದರ ಮೇಲಿನ-ಬಲ ಮೂಲೆಯಲ್ಲಿ ನಕಲು ಐಕಾನ್ ಅನ್ನು ಹೊಂದಿದೆ, ಆದ್ದರಿಂದ ನೀವು ಮುಗಿದ ವರದಿ, ಡಾಕ್ಯುಮೆಂಟ್, ಅಥವಾ ನೀವು ಚಲಾಯಿಸಬೇಕಾದ ಆಜ್ಞೆಯನ್ನು ನಕಲಿಸಬಹುದು.
html.parser ಬದಲಿಗೆ lxml ಬಳಸಿ").@deepcerebra ನೊಂದಿಗೆ ಚಾಟ್ನಲ್ಲಿ ಏಜೆಂಟ್ ಅನ್ನು ಆಹ್ವಾನಿಸುತ್ತೀರಿ, ಮತ್ತು [deep] ನಂತಹ ಪೂರ್ವಪ್ರತ್ಯಯಗಳು ಆಳವಾದ ತಾರ್ಕಿಕತೆಯನ್ನು ವಿನಂತಿಸುತ್ತವೆ.ಪ್ರಾಂಪ್ಟ್ ಪಕ್ಕದಲ್ಲಿರುವ ಮೋಡ್ ಸೆಲೆಕ್ಟರ್ನಿಂದ ಒಂದು ಮೋಡ್ ಅನ್ನು ಆಯ್ಕೆಮಾಡಿ. ಪ್ರತಿಯೊಂದೂ ಏಜೆಂಟ್ ಎಷ್ಟು ಯೋಜನೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಎಷ್ಟು ಮುಕ್ತವಾಗಿ ಸಂಪಾದಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಟ್ಯೂನ್ ಮಾಡುತ್ತದೆ:
| ಮೋಡ್ | ಅದು ಏನು ಮಾಡುತ್ತದೆ | ಇದನ್ನು ಯಾವಾಗ ಬಳಸಿ… |
|---|---|---|
| ಏಜೆಂಟ್ | ನಿಮ್ಮ ಯೋಜನೆಯಾದ್ಯಂತ ಸ್ವಾಯತ್ತವಾಗಿ ಯೋಜನೆಗಳು ಮತ್ತು ಸಂಪಾದನೆಗಳು | ಸಹಾಯಕವು ಬದಲಾವಣೆಯನ್ನು ಕೊನೆಯಿಂದ ಕೊನೆಯವರೆಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಲು ನೀವು ಬಯಸಿದಾಗ |
| ಕೇಳಿ | ಸಂಪಾದಿಸದೆ ನಿಮ್ಮ ಕೋಡ್ ಬಗ್ಗೆ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸುತ್ತದೆ | ಕೋಡ್ಬೇಸ್ ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನೀವು ಬಯಸಿದಾಗ |
| ಯೋಜನೆ | ಯಾವುದೇ ಸಂಪಾದನೆಗೆ ಮೊದಲು ಒಂದು ವಿಧಾನವನ್ನು ಕರಡು ಮಾಡುತ್ತದೆ | ಕಾರ್ಯವು ದೊಡ್ಡದಾಗಿದ್ದಾಗ ಅಥವಾ ಮೊದಲು ಇತ್ಯರ್ಥಪಡಿಸಬೇಕಾದ ವಿನಿಮಯಗಳನ್ನು ಹೊಂದಿರುವಾಗ |
| ಸಂಪಾದಿಸಿ | ಪ್ರಸ್ತುತ ಸಂದರ್ಭದಲ್ಲಿ ಕೇಂದ್ರೀಕೃತ ಸಂಪಾದನೆಗಳನ್ನು ಮಾಡುತ್ತದೆ | ನೀವು ಸಣ್ಣ, ಉದ್ದೇಶಿತ ಬದಲಾವಣೆಯನ್ನು ಬಯಸಿದಾಗ |
ಏಜೆಂಟ್ ಫೈಲ್ ಬದಲಾವಣೆಗಳನ್ನು ಪ್ರಸ್ತಾಪಿಸಿದಾಗ, ಒಂದು ಪ್ರಸ್ತಾವಿತ ಬದಲಾವಣೆಗಳು ಫಲಕವು ಚಾಟ್ ಇನ್ಪುಟ್ನ ಮೇಲೆ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ, ಪ್ರತಿ ಸ್ಪರ್ಶಿಸಿದ ಫೈಲ್ ಅನ್ನು ಸೇರಿಸಿದ (+) ಮತ್ತು ತೆಗೆದುಹಾಕಿದ (−) ಸಾಲುಗಳ ಎಣಿಕೆಗಳೊಂದಿಗೆ ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ.
applied ಎಂದು ಗುರುತಿಸಲಾಗುತ್ತದೆ (ಮತ್ತು ನಿಜವಾದ ಫೋಲ್ಡರ್ಗೆ ಬರೆದಾಗ · disk).ಬಿಲ್ಡ್ಗಳು, ಪರೀಕ್ಷೆಗಳು ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್ಗಳನ್ನು ಚಲಾಯಿಸಲು ಎಡಿಟರ್ನ ಕೆಳಗಿರುವ ಟರ್ಮಿನಲ್ ಅನ್ನು ಟಾಗಲ್ ಮಾಡಿ. ನಿಮ್ಮ ಅನುಮತಿಯೊಂದಿಗೆ, ಏಜೆಂಟ್ ಆಜ್ಞೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು ಮತ್ತು ಅದರ ಕೆಲಸವನ್ನು ಪರಿಶೀಲಿಸಲು ಅವುಗಳ ಔಟ್ಪುಟ್ ಅನ್ನು ಓದಬಹುದು; ದೀರ್ಘಕಾಲದ ಆಜ್ಞೆಗಳು ಔಟ್ಪುಟ್ ಅನ್ನು ಸ್ಟ್ರೀಮ್ ಮಾಡುತ್ತವೆ, ಇದರಿಂದ ನೀವು ಪ್ರಗತಿಯನ್ನು ವೀಕ್ಷಿಸಬಹುದು. ನಿಮಗೆ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದಾಗ ಅದರ ಹೆಡರ್ನಿಂದ ಟರ್ಮಿನಲ್ ಅನ್ನು ಮುಚ್ಚಿ.
ದೊಡ್ಡ ಗುರಿಗಳಿಗಾಗಿ, ಯೋಜನೆ ಮೋಡ್ ಬಳಸಿ (ಅಥವಾ ಏಜೆಂಟ್ ಅನ್ನು ಮೊದಲು ಯೋಜನೆ ಮಾಡಲು ಕೇಳಿ). ಯೋಜಕವು ನಿಮ್ಮ ಯೋಜನೆಯನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡುತ್ತದೆ, ಗುರಿಯನ್ನು ಅವಲಂಬಿತ-ಅರಿವಿನ ಕಾರ್ಯಗಳಾಗಿ ವಿಭಜಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರತಿಯೊಂದನ್ನು ಸರಿಯಾದ ತಜ್ಞರಿಗೆ (ವಾಸ್ತುಶಿಲ್ಪಿ, ಕೋಡರ್, ಪರೀಕ್ಷಕ, ದಾಖಲೆಗಳು) ನಿಯೋಜಿಸುತ್ತದೆ.
ಪ್ರಾಂಪ್ಟ್ ಪಕ್ಕದಲ್ಲಿರುವ ಮಾದರಿ ಪಿಕ್ಕರ್ ಅನ್ನು ತೆರೆಯಿರಿ. ಆಯ್ಕೆಗಳನ್ನು ಹೀಗೆ ಗುಂಪು ಮಾಡಲಾಗಿದೆ:
Auto ದಲ್ಲಿ, DeepCerebra ಶ್ರೇಣೀಕೃತ, ಹೊಂದಾಣಿಕೆಯ ರೂಟಿಂಗ್ ಅನ್ನು ಬಳಸುತ್ತದೆ: ಸರಳ ಕಾರ್ಯಗಳನ್ನು ವೇಗದ, ಮಿತವ್ಯಯದ ಮಾದರಿಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ, ಆದರೆ ಸಂಕೀರ್ಣ ಅಥವಾ ಯೋಜನೆ-ಭರಿತ ಕೆಲಸವನ್ನು (ಉದಾಹರಣೆಗೆ, Plan mode) ಹೆಚ್ಚು ಶಕ್ತಿಯುತ ಮಾದರಿಗೆ ರೂಟ್ ಮಾಡಲಾಗುತ್ತದೆ. ಇದು ವೆಚ್ಚ ಮತ್ತು ಗುಣಮಟ್ಟವನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸಮತೋಲನಗೊಳಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ನೀವು ಕೈಯಾರೆ ಆಯ್ಕೆ ಮಾಡಬೇಕಾದ ಅಗತ್ಯ ವಿರಳವಾಗಿರುತ್ತದೆ.
ಮೀಟರ್ ಮಾಡಿದ ಪ್ಲಾಟ್ಫಾರ್ಮ್ ಬಳಕೆಯ ಬದಲಿಗೆ ನಿಮ್ಮ ಸ್ವಂತ ಪೂರೈಕೆದಾರ ಖಾತೆಯ ಮೂಲಕ ವಿನಂತಿಗಳನ್ನು ರೂಟ್ ಮಾಡಬಹುದು.
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 ಅಥವಾ 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-ಬೆಂಬಲಿತ ಯೋಜನೆ ತೆರೆದಾಗ, ಎಕ್ಸ್ಪ್ಲೋರರ್ನಲ್ಲಿ ನಿಮ್ಮ ಪ್ರಸ್ತುತ ಬ್ರಾಂಚ್ ಮತ್ತು ಎರಡು ಕ್ರಿಯೆಗಳನ್ನು ತೋರಿಸುವ ಬ್ರಾಂಚ್ ಬಾರ್ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ:
main) ಪುಲ್ ವಿನಂತಿಯನ್ನು ತೆರೆಯಿರಿ. ನೀವು ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಬ್ರಾಂಚ್ನಲ್ಲಿರಬೇಕು, ಡೀಫಾಲ್ಟ್ ಬ್ರಾಂಚ್ನಲ್ಲಿ ಅಲ್ಲ.ಪುಶ್ ವೆಬ್ಹುಕ್ ಸಕ್ರಿಯಗೊಳಿಸಿದ್ದರೆ, ಸಹೋದ್ಯೋಗಿಗಳು ಪುಶ್ ಮಾಡಿದಾಗ ಎಕ್ಸ್ಪ್ಲೋರರ್ ಸ್ವಯಂ-ರಿಫ್ರೆಶ್ ಆಗುತ್ತದೆ, ಎಲ್ಲರನ್ನು ಸಿಂಕ್ನಲ್ಲಿ ಇರಿಸುತ್ತದೆ — DeepCerebra ಮೂಲಕ ಸಹಯೋಗದ ತಂಡದ ಅಭಿವೃದ್ಧಿಗೆ ಅಡಿಪಾಯ.
ಮಾದರಿ ಸಂದರ್ಭ ಪ್ರೋಟೋಕಾಲ್ ಮೂಲಕ ಬಾಹ್ಯ ಪರಿಕರಗಳು ಮತ್ತು ಡೇಟಾದೊಂದಿಗೆ ಏಜೆಂಟ್ ಅನ್ನು ವಿಸ್ತರಿಸಿ. .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) ಆ ಫೋಲ್ಡರ್ ಅಡಿಯಲ್ಲಿರುವ ಫೈಲ್ಗಳಿಗೆ ಮಾತ್ರ ಅನ್ವಯಿಸುತ್ತದೆ. ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ನಲ್ಲಿ,
ಏಜೆಂಟ್ → ಸ್ಟೀರಿಂಗ್ ವೀಕ್ಷಣೆ ಪ್ರತಿ ನಿಯಮಕ್ಕೆ ವ್ಯಾಪ್ತಿ ಪಿಕ್ಕರ್ ಅನ್ನು ನೀಡುತ್ತದೆ
(ಜಾಗತಿಕ / ಯೋಜನೆ / ತಂಡ).
ಕೌಶಲ್ಯಗಳು ಏಜೆಂಟ್ ಬೇಡಿಕೆಯ ಮೇರೆಗೆ ಲೋಡ್ ಮಾಡುವ ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಪ್ಲೇಬುಕ್ಗಳಾಗಿವೆ. ಪ್ರತಿ ಕೌಶಲ್ಯವು
.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/ ಅಡಿಯಲ್ಲಿ ಫ್ರಂಟ್ಮ್ಯಾಟರ್ ಜೊತೆಗೆ ದೇಹವನ್ನು (ಅದರ ಸಿಸ್ಟಮ್ ಪ್ರಾಂಪ್ಟ್) ಹೊಂದಿರುವ ಮಾರ್ಕ್ಡೌನ್ ಫೈಲ್ ಆಗಿದೆ:
---
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 ಡೈರೆಕ್ಟರಿಗೆ ಸೂಚಿಸುವ ಮೂಲಕ, ಅಥವಾ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ನಲ್ಲಿ ನಿಯಮಗಳನ್ನು ತಂಡ ಸ್ಕೋಪ್ಗೆ ಹೊಂದಿಸುವ ಮೂಲಕ ಹಂಚಿದ ಡೀಫಾಲ್ಟ್ಗಳನ್ನು ಪ್ರಕಟಿಸಬಹುದು.ವರ್ಕ್ಫ್ಲೋ ಸ್ಟುಡಿಯೋ ಬಹು-ಏಜೆಂಟ್ ಯಾಂತ್ರೀಕರಣಕ್ಕಾಗಿ ಒಂದು ದೃಶ್ಯ ವಿನ್ಯಾಸಕವಾಗಿದೆ. ನೀವು ಹಂತಗಳನ್ನು — ಪ್ರತಿಯೊಂದೂ ಒಂದು ಏಜೆಂಟ್, ಒಂದು ತಜ್ಞ ಹಂತ, ಅಥವಾ ಒಂದು ನಿಯಂತ್ರಣ ಪ್ರಾಚೀನ — ಒಂದು ಗ್ರಾಫ್ ಆಗಿ ಸಂಯೋಜಿಸುತ್ತೀರಿ, ಅವುಗಳನ್ನು ಅವಲಂಬನೆಗಳೊಂದಿಗೆ ಸಂಪರ್ಕಿಸುತ್ತೀರಿ, ಮತ್ತು ಲೈವ್ ಪ್ರತಿ-ಹಂತದ ಪ್ರಗತಿ, ಬಜೆಟ್ಗಳು, ಮತ್ತು ಮಾನವ-ಅನುಮೋದನೆ ಗೇಟ್ಗಳೊಂದಿಗೆ ಎಂಜಿನ್ನಲ್ಲಿ ಸಂಪೂರ್ಣ ಆರ್ಕೆಸ್ಟ್ರೇಶನ್ ಅನ್ನು ಚಲಾಯಿಸುತ್ತೀರಿ. ವರ್ಕ್ಫ್ಲೋಗಳನ್ನು ಪೋರ್ಟಬಲ್ 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 | ಚೆಕ್ಗಳ ವಿರುದ್ಧ ಅಪ್ಸ್ಟ್ರೀಮ್ ಔಟ್ಪುಟ್ ಅನ್ನು ಸ್ಕೋರ್ ಮಾಡಿ (ಒಳಗೊಂಡಿದೆ / ರೆಜೆಕ್ಸ್ / ಉದ್ದ / LLM-ನ್ಯಾಯಾಧೀಶ); ಒಂದು ಮಿತಿಗಿಂತ ಕೆಳಗೆ ವಿಫಲಗೊಳ್ಳಿ. |
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 | ಉತ್ಪಾದನಾ ನಿಯೋಜನೆ ಆಸ್ತಿಗಳನ್ನು ರಚಿಸಿ: ಬಹು-ಹಂತದ Dockerfile, docker-compose, Kubernetes ಮ್ಯಾನಿಫೆಸ್ಟ್ಗಳು, ಅಥವಾ Helm ಚಾರ್ಟ್ — ನೀವು ಹೊಂದಿರುವ ಮತ್ತು ಕಮಿಟ್ ಮಾಡುವ ಫೈಲ್ಗಳು. |
test.generate | ನಿರ್ಮಿಸಿದ ಅಪ್ಲಿಕೇಶನ್ಗಾಗಿ ಯೂನಿಟ್ / API / E2E ಸೂಟ್ಗಳನ್ನು ಮತ್ತು ಅವಶ್ಯಕತೆ-ಪರೀಕ್ಷೆಗೆ ಟ್ರೇಸಬಿಲಿಟಿ ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಅನ್ನು ರಚಿಸಿ. |
test.verify | ಒಂದು ಪರೀಕ್ಷಾ ಸೂಟ್ ಅನ್ನು (pytest, vitest, jest, Playwright) ಕಾರ್ಯಗತಗೊಳಿಸಿ ಮತ್ತು ಅದರ ಪಾಸ್ ದರದ ಮೇಲೆ ರನ್ ಅನ್ನು ಗೇಟ್ ಮಾಡಿ. |
security.audit | ತಿಳಿದಿರುವ ದೋಷಗಳಿಗಾಗಿ ಅವಲಂಬನೆಗಳನ್ನು ಮತ್ತು ಹಾರ್ಡ್-ಕೋಡೆಡ್ ರಹಸ್ಯಗಳಿಗಾಗಿ ಟ್ರೀ ಅನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡಿ; ಎಚ್ಚರಿಕೆ ಘಟನೆಗಳನ್ನು ಪ್ರಕಟಿಸುತ್ತದೆ ಮತ್ತು ಸಂಶೋಧನೆಗಳ ವರದಿಯನ್ನು ಬರೆಯುತ್ತದೆ. |
preview | ರಚಿಸಿದ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸ್ಥಳೀಯವಾಗಿ ಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ಅದರ ಲೈವ್ URL ಅನ್ನು ರನ್ ಪ್ಯಾನೆಲ್ನಲ್ಲಿ
(ಲಿಂಕ್ + ಇನ್ಲೈನ್ ಫ್ರೇಮ್) preview.ready ಈವೆಂಟ್ ಮೂಲಕ ಮೇಲ್ಮೈಗೆ ತನ್ನಿ. |
design.import | UI ವಿನ್ಯಾಸ ಚಿತ್ರವನ್ನು (ಸ್ಕ್ರೀನ್ಶಾಟ್, ಮಾಕ್ಅಪ್, Figma ರಫ್ತು) ಡೌನ್ಸ್ಟ್ರೀಮ್ ಹಂತಗಳಿಗಾಗಿ ರಚನಾತ್ಮಕ ಅನುಷ್ಠಾನ ಸ್ಪೆಕ್ ಆಗಿ ಪರಿವರ್ತಿಸಿ. |
ಪ್ರತಿ ಹಂತ — ಪ್ರಕಾರವನ್ನು ಲೆಕ್ಕಿಸದೆ — ಕಾರ್ಯಕ್ಷೇತ್ರದ ಈವೆಂಟ್ ಬಸ್ನಲ್ಲಿ ಟೈಪ್ ಮಾಡಿದ ಈವೆಂಟ್ಗಳನ್ನು ಪ್ರಕಟಿಸಬಹುದು ಮತ್ತು ಚಂದಾದಾರರಾಗಬಹುದು, ಆದ್ದರಿಂದ ಏಜೆಂಟ್ಗಳು DAG ಮೂಲಕ ಮಾತ್ರವಲ್ಲದೆ ಸಂದೇಶ ಫ್ಯಾಬ್ರಿಕ್ನಲ್ಲಿ ಸೇವೆಗಳಂತೆ ಸಂಯೋಜಿಸುತ್ತವೆ:
lifecycle, agent, business, data, system, schedule, chat, external, or 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 minutesರೆಂಡೆಜ್ವಸ್ ಮುಂದಿನ ಹಂತವು ಮುಂದುವರಿಯುವ ಮೊದಲು ಹಲವಾರು ಈವೆಂಟ್ ಷರತ್ತುಗಳು ಎಲ್ಲವೂ ಪೂರೈಸಲ್ಪಡುವವರೆಗೆ ಕಾಯುತ್ತದೆ — "ಮೊದಲ ಈವೆಂಟ್ ಗೆಲ್ಲುತ್ತದೆ" ಎಂಬುದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿದೆ. ಸ್ಟೇಜ್ನ events: ಬ್ಲಾಕ್ನಲ್ಲಿ join: all ಅನ್ನು ಹೊಂದಿಸಿ: ಸ್ಟೇಜ್ ರನ್ ಆಗುವ ಮೊದಲು ಪ್ರತಿಯೊಂದು ಟ್ರಿಗರ್ ಚಂದಾದಾರಿಕೆಯು ಪೂರೈಸಲ್ಪಡಬೇಕು. ಹಲವಾರು ಏಜೆಂಟ್ಗಳು (ಅಥವಾ ಒಬ್ಬ ಏಜೆಂಟ್ನಿಂದ ಹಲವಾರು ವರದಿಗಳು) ಎಲ್ಲವೂ ಚೆಕ್ ಇನ್ ಆಗಬೇಕಾದಾಗ ಪ್ರತಿ-ಚಂದಾದಾರಿಕೆಯ count: N ನೊಂದಿಗೆ ಸಂಯೋಜಿಸಿ — ಉದಾಹರಣೆಗೆ, ಬಿಡುಗಡೆ ಹಂತವು ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಮೊದಲು ವಿನ್ಯಾಸದ ಅನುಮೋದನೆ, ಪರೀಕ್ಷೆಯ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ ಮತ್ತು ಭದ್ರತಾ ಅನುಮೋದನೆ.
join: any (ಡೀಫಾಲ್ಟ್) — ಮೊದಲ ಟ್ರಿಗ್ಗರ್ ಚಂದಾದಾರಿಕೆ ತೃಪ್ತಿಪಡಿಸಿದಾಗ ಹಂತವು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.join: all — rendezvous: ಪ್ರತಿ ಟ್ರಿಗರ್ ಚಂದಾದಾರಿಕೆ (ಪ್ರತಿಯೊಂದೂ ತನ್ನದೇ ಆದ ವಿಷಯ, ವರ್ಗ ಫಿಲ್ಟರ್ ಮತ್ತು ಐಚ್ಛಿಕ 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') ನೊಂದಿಗೆ ರನ್ಟೈಮ್ನಲ್ಲಿ ಸಕ್ರಿಯಗೊಳಿಸಿ (ನಂತರ ಮರುಲೋಡ್ ಮಾಡಿ).ನಿಮ್ಮ ಯೋಜನೆ ಮತ್ತು ಬಳಕೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಸೈಡ್ಬಾರ್ನಿಂದ ಬಿಲ್ಲಿಂಗ್ ತೆರೆಯಿರಿ. AI ಬಳಕೆಯನ್ನು ಆಧಾರವಾಗಿರುವ ಮಾದರಿಗಳಿಂದ ಸೇವಿಸಿದ ಟೋಕನ್ಗಳ ಆಧಾರದ ಮೇಲೆ U.S.-ಡಾಲರ್ ಕ್ರೆಡಿಟ್ಗಳಲ್ಲಿ ಮೀಟರ್ ಮಾಡಲಾಗುತ್ತದೆ.
| ಯೋಜನೆ | ಮಾಸಿಕ ಬೆಲೆ | ಸೇರಿಸಿದ ಮಾಸಿಕ AI ಬಳಕೆ |
|---|---|---|
| ಮೂಲ | $20 | $10 |
| ಪ್ರೊ | $75 | $30 |
| ಅಲ್ಟಿಮೇಟ್ | $200 | $150 |
ಒಂದು ಗೇಟ್ವೇ 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) ನೀವು ಬ್ರೌಸರ್ನಲ್ಲಿ ಬಳಸುವ ಅದೇ ಡೊಮೇನ್ ಅನ್ನು ಬಳಸಿ — ಎರಡು ಸೈಟ್ಗಳು ಪ್ರತ್ಯೇಕ ನಿಯೋಜನೆಗಳಾಗಿವೆ, ಮತ್ತು ಒಂದರಿಂದ ಬಂದ ಟೋಕನ್ ಇನ್ನೊಂದರಲ್ಲಿ ಎಂದಿಗೂ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ.ಪುಲ್ ವಿನಂತಿಯನ್ನು ತೆರೆಯಲು ಸಂಯೋಜಿಸಿ ಬಳಸುವ ಮೊದಲು ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಬ್ರಾಂಚ್ ಅನ್ನು ತೆರೆಯಿರಿ ಅಥವಾ ರಚಿಸಿ.
ಇನ್ನೂ ಸಿಕ್ಕಿಬಿದ್ದಿದ್ದೀರಾ? support@deepcerebra.ai ಅನ್ನು ಸಂಪರ್ಕಿಸಿ.
Discovery ನಿಮ್ಮ ಡೇಟಾಬೇಸ್ಗಳು ಮತ್ತು ಡಾಕ್ಯುಮೆಂಟ್ಗಳಿಗಾಗಿ ಒಂದು ತನಿಖಾ ಚಾಟ್ಬಾಟ್ ಆಗಿದೆ. ಒಂದೇ ಪ್ರಶ್ನೆಯೊಂದಿಗೆ ಉತ್ತರಿಸುವ ಬದಲು, ಇದು ವಿಶ್ಲೇಷಕರಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ: ಇದು ಊಹೆಗಳನ್ನು ರೂಪಿಸುತ್ತದೆ, ಸರಣಿ ಸಂರಕ್ಷಿತ ತನಿಖೆಗಳನ್ನು (SQL, ಗ್ರಾಫ್, ಡಾಕ್ಯುಮೆಂಟ್ ಹುಡುಕಾಟ, ಸ್ಕೀಮಾ ಪರಿಶೀಲನೆಗಳು, ವೆಬ್ ದೃಢೀಕರಣ) ನಡೆಸುತ್ತದೆ, ಸಾಕ್ಷ್ಯವು ನಿರಾಕರಿಸುವ ವಿವರಣೆಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ, ಮತ್ತು ಚಾರ್ಟ್ಗಳು ಹಾಗೂ ಪಾರದರ್ಶಕ ವೆಚ್ಚದ ರಸೀದಿಯೊಂದಿಗೆ ಒಂದು ಆಧಾರಿತ ಉತ್ತರವನ್ನು ಸಂಶ್ಲೇಷಿಸುತ್ತದೆ. ಇದನ್ನು ಆಕ್ಟಿವಿಟಿ ರೈಲ್ನಲ್ಲಿರುವ ದಿಕ್ಸೂಚಿ ಐಕಾನ್ನಿಂದ (/app/discovery) ತೆರೆಯಿರಿ.
ಒಂದು ಸ್ಪೇಸ್ ಒಂದು ಪ್ರಶ್ನಾವಳಿಯ ಸಾಲಿಗೆ ಬೇಕಾದ ಎಲ್ಲವನ್ನೂ ಒಟ್ಟುಗೂಡಿಸುತ್ತದೆ: ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕಗಳು, ಡಾಕ್ಯುಮೆಂಟ್ ಸಂಗ್ರಹಗಳು, ವಿಶ್ಲೇಷಕರಿಗೆ ಸೂಚನೆಗಳು ಮತ್ತು ಬಜೆಟ್ಗಳು. + ಹೊಸ ಸ್ಪೇಸ್ ಮೂಲಕ ಒಂದನ್ನು ರಚಿಸಿ, ನಂತರ ಬಲಭಾಗದಲ್ಲಿರುವ ಸೆಟಪ್ ಪ್ಯಾನೆಲ್ ಅನ್ನು ಬಳಸಿ:
ನೀವು ಸಹೋದ್ಯೋಗಿಯನ್ನು ಕೇಳುವ ರೀತಿಯಲ್ಲಿ ಪ್ರಶ್ನೆಯನ್ನು ಟೈಪ್ ಮಾಡಿ — ಉದಾಹರಣೆಗೆ "ಮಾರ್ಚ್ನಲ್ಲಿ MRI ಸ್ಕ್ಯಾನ್ ಪ್ರಮಾಣ ಏಕೆ ಕುಸಿಯಿತು?". ತನಿಖಾ ಮಂಡಳಿ ಸಂಪೂರ್ಣ ಪ್ರಕ್ರಿಯೆಯನ್ನು ನೇರವಾಗಿ ಪ್ರಸಾರ ಮಾಡುತ್ತದೆ:
ಮುಂದುವರಿದ ಪ್ರಶ್ನೆಗಳು ಅದೇ ಥ್ರೆಡ್ ಅನ್ನು ಮುಂದುವರಿಸುತ್ತವೆ, ಆದ್ದರಿಂದ ವಿಶ್ಲೇಷಕರು ಅದರ ಸಂದರ್ಭವನ್ನು ಉಳಿಸಿಕೊಳ್ಳುತ್ತಾರೆ.
ಚಾರ್ಟ್ಗಳು ತನಿಖಾ ಮಂಡಳಿಯಲ್ಲಿ ಇನ್ಲೈನ್ ಆಗಿ ರೆಂಡರ್ ಆಗುತ್ತವೆ. ಸಂಪೂರ್ಣ ಪ್ರಶ್ನೆಯನ್ನು — ಉತ್ತರ, ಊಹೆಗಳು, ಸಾಕ್ಷ್ಯ ಮತ್ತು ಚಾರ್ಟ್ಗಳನ್ನು — ಸ್ವಯಂ-ಒಳಗೊಂಡಿರುವ HTML ವರದಿ ಅಥವಾ ಮುದ್ರಣ-ಗುಣಮಟ್ಟದ PDF ಆಗಿ ಡೌನ್ಲೋಡ್ ಮಾಡಲು ರಫ್ತು ಬಳಸಿ, ಇದನ್ನು ನಿಯಾನ್ ವಿನ್ಯಾಸ ವ್ಯವಸ್ಥೆಯೊಂದಿಗೆ ಶೈಲೀಕರಿಸಲಾಗಿದೆ.
ಪ್ರತಿ ಸ್ಪೇಸ್ ಪ್ರತಿ-ಪ್ರಶ್ನೆ ಬಜೆಟ್ಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ: ಗರಿಷ್ಠ ಸಂಖ್ಯೆಯ ತನಿಖೆಗಳು, ತನಿಖಾ ಸುತ್ತುಗಳು, ಸೆಕೆಂಡುಗಳು ಮತ್ತು USD. ಎಂಜಿನ್ ಮಿತಿಯಲ್ಲಿ ಸ್ವಚ್ಛವಾಗಿ ನಿಲ್ಲುತ್ತದೆ ಮತ್ತು ಇಲ್ಲಿಯವರೆಗೆ ಕಂಡುಕೊಂಡದ್ದನ್ನು ವರದಿ ಮಾಡುತ್ತದೆ. ಪ್ರತಿ ತನಿಖೆಯ ವೆಚ್ಚವನ್ನು ರಸೀದಿಯಲ್ಲಿ ಐಟಂವಾರು ಪಟ್ಟಿ ಮಾಡಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ವೆಚ್ಚ ಎಲ್ಲಿ ಹೋಯಿತು ಎಂದು ನಿಮಗೆ ಯಾವಾಗಲೂ ತಿಳಿಯುತ್ತದೆ.
/v1/discovery/* ಅಡಿಯಲ್ಲಿ discovery ಸ್ಕೋಪ್ ಹೊಂದಿರುವ PAT ನೊಂದಿಗೆ ಲಭ್ಯವಿದೆ (ಇದನ್ನು ಖಾತೆ → API ಟೋಕನ್ಗಳು ಅಡಿಯಲ್ಲಿ ರಚಿಸಿ). ಸ್ಟ್ರೀಮಿಂಗ್ ಪ್ರಶ್ನೆಗಳು 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 ಕ್ಲೈಂಟ್ಗಳು ಸಹ ತನಿಖೆಗಳನ್ನು ನಡೆಸಬಹುದು.