1 ਜਾਣ-ਪਛਾਣ ਅਤੇ ਐਡੀਸ਼ਨ

DeepCerebra Coder ਇੱਕ ਏਜੰਟਿਕ ਕੋਡਿੰਗ ਸਹਾਇਕ ਹੈ। ਇੱਕ ਸਧਾਰਨ ਆਟੋਕੰਪਲੀਟ ਕੋਪਾਇਲਟ ਦੇ ਉਲਟ, ਇਹ ਯੋਜਨਾ ਬਣਾਉਂਦਾ ਹੈ, ਲਿਖਦਾ ਹੈ, ਰੀਫੈਕਟਰ ਕਰਦਾ ਹੈ, ਕਮਾਂਡਾਂ ਚਲਾਉਂਦਾ ਹੈ, ਟੂਲਸ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ, ਅਤੇ ਤੁਹਾਡੇ ਪੂਰੇ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਦੁਹਰਾਉਂਦਾ ਹੈ — ਤੁਹਾਡੇ ਦੁਆਰਾ ਇਸਦੇ ਪ੍ਰਸਤਾਵਿਤ ਬਦਲਾਵਾਂ ਦੀ ਸਮੀਖਿਆ ਅਤੇ ਪ੍ਰਵਾਨਗੀ ਦੇ ਨਾਲ।

ਇਸਨੂੰ ਵਰਤਣ ਦੇ ਤਿੰਨ ਤਰੀਕੇ

ਇਹ ਗਾਈਡ deepcerebra.ai 'ਤੇ ਵੈੱਬ ਐਪ 'ਤੇ ਕੇਂਦਰਿਤ ਹੈ; ਡੈਸਕਟਾਪ ਐਪ ਉਸੇ ਪੈਨਲਾਂ ਅਤੇ ਵਰਕਫਲੋ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ।

2 ਸ਼ੁਰੂਆਤ ਕਰਨਾ ਅਤੇ ਖਾਤਾ

ਸਮਰਥਿਤ ਬ੍ਰਾਊਜ਼ਰ

ਦਾ ਮੌਜੂਦਾ ਸੰਸਕਰਣ ਵਰਤੋ Chrome, Edge, or Brave ਪੂਰੇ ਅਨੁਭਵ ਲਈ — ਇੱਕ ਸਥਾਨਕ ਫੋਲਡਰ Chromium ਫਾਈਲ ਸਿਸਟਮ ਐਕਸੈਸ API 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਫਾਇਰਫਾਕਸ ਅਤੇ ਸਫਾਰੀ ਚੈਟ ਅਤੇ ਗਿੱਟ-ਬੈਕਡ ਪ੍ਰੋਜੈਕਟਾਂ ਲਈ ਕੰਮ ਕਰਦੇ ਹਨ, ਪਰ ਸਥਾਨਕ ਫੋਲਡਰ ਨੂੰ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਨਹੀਂ ਖੋਲ੍ਹ ਸਕਦੇ।

ਇੱਕ ਖਾਤਾ ਬਣਾਓ

1. ਲੈਂਡਿੰਗ ਪੇਜ 'ਤੇ ਸ਼ੁਰੂ ਕਰੋ 'ਤੇ ਕਲਿੱਕ ਕਰੋ।
2. ਆਪਣਾ ਵਿਕਲਪਿਕ ਡਿਸਪਲੇ ਨਾਮ, ਈਮੇਲ, ਦੇਸ਼, ਅਤੇ ਜਨਮ ਮਿਤੀ ਭਰੋ (ਤੁਹਾਡੀ ਉਮਰ ਘੱਟੋ-ਘੱਟ 18 ਸਾਲ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ)।
3. ਆਪਣੀ ਇੰਟਰਫੇਸ ਭਾਸ਼ਾ ਅਤੇ ਘੱਟੋ-ਘੱਟ 12 ਅੱਖਰਾਂ ਦਾ ਇੱਕ ਪਾਸਵਰਡ ਚੁਣੋ।
4. ਸਮਝੌਤੇ ਦਾ ਨੋਟਿਸ ਪੜ੍ਹੋ ਅਤੇ ਪੁਸ਼ਟੀ ਕਰੋ। ਇੱਕ ਖਾਤਾ ਬਣਾਉਣ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਸੀਂ ਸੇਵਾ ਦੀਆਂ ਸ਼ਰਤਾਂ, ਗੋਪਨੀਯਤਾ ਬਿਆਨ, ਸੇਵਾਵਾਂ ਦਾ ਵੇਰਵਾ, ਅਤੇ ਗਲੋਬਲ DPA ਨਾਲ ਸਹਿਮਤ ਹੋ।
5. ਖਾਤਾ ਬਣਾਓ 'ਤੇ ਕਲਿੱਕ ਕਰੋ, ਫਿਰ ਜੇਕਰ ਪੁੱਛਿਆ ਜਾਵੇ ਤਾਂ ਆਪਣੀ ਈਮੇਲ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ, ਅਤੇ ਸਾਈਨ ਇਨ ਕਰੋ।

ਆਪਣਾ ਪਾਸਵਰਡ ਰੀਸੈਟ ਕਰੋ

1. ਲੌਗਇਨ ਪੇਜ 'ਤੇ, ਪਾਸਵਰਡ ਭੁੱਲ ਗਏ? 'ਤੇ ਕਲਿੱਕ ਕਰੋ।
2. ਆਪਣੀ ਈਮੇਲ ਦਰਜ ਕਰੋ ਅਤੇ ਆਪਣੇ ਇਨਬਾਕਸ ਵਿੱਚ ਭੇਜੇ ਗਏ ਰੀਸੈਟ ਲਿੰਕ ਨੂੰ ਖੋਲ੍ਹੋ।
3. ਇੱਕ ਨਵਾਂ ਪਾਸਵਰਡ ਸੈੱਟ ਕਰੋ (ਘੱਟੋ-ਘੱਟ 12 ਅੱਖਰ)।

3 ਵਰਕਸਪੇਸ 'ਤੇ ਇੱਕ ਨਜ਼ਰ

ਸਾਈਨ ਇਨ ਕਰਨ ਤੋਂ ਬਾਅਦ ਤੁਸੀਂ ਵਰਕਬੈਂਚ ਵਿੱਚ ਪਹੁੰਚਦੇ ਹੋ, ਜੋ ਹਰ ਪੈਨ ਨੂੰ ਇੱਕ ਸਕ੍ਰੀਨ ਵਿੱਚ ਰੱਖਦਾ ਹੈ:

• ਐਕਸਪਲੋਰਰ (ਖੱਬੇ) — ਖੁੱਲ੍ਹੇ ਪ੍ਰੋਜੈਕਟ ਲਈ ਫਾਈਲ ਟ੍ਰੀ, ਇੱਕ ਰਿਫ੍ਰੈਸ਼ ਅਤੇ ਬੰਦ ਬਟਨ ਦੇ ਨਾਲ।
• ਐਡੀਟਰ (ਕੇਂਦਰ) — ਸਿੰਟੈਕਸ ਹਾਈਲਾਈਟਿੰਗ ਅਤੇ ਇੱਕ ਮਿਨੀਮੈਪ ਸੰਖੇਪ ਜਾਣਕਾਰੀ ਦੇ ਨਾਲ ਫਾਈਲ ਸਮੱਗਰੀ; ਇੱਥੇ ਇਨਲਾਈਨ ਡਿਫਸ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ ਜਦੋਂ ਏਜੰਟ ਤਬਦੀਲੀਆਂ ਦਾ ਪ੍ਰਸਤਾਵ ਕਰਦਾ ਹੈ।
• ਟਰਮੀਨਲ (ਐਡੀਟਰ ਦੇ ਹੇਠਾਂ, ਚਾਲੂ/ਬੰਦ ਟੌਗਲ ਕਰੋ) — ਕਮਾਂਡਾਂ ਚਲਾਓ ਅਤੇ ਆਉਟਪੁੱਟ ਪੜ੍ਹੋ।
• ਚੈਟ (ਸੱਜੇ) — ਏਜੰਟ ਦੀ ਗੱਲਬਾਤ; ਇਹ ਮੁੱਖ, ਥਾਂ ਘੇਰਨ ਵਾਲਾ ਪੈਨ ਹੈ।

ਲੇਆਉਟ ਨੂੰ ਮੁੜ-ਸੰਤੁਲਿਤ ਕਰਨ ਲਈ ਐਡੀਟਰ ਅਤੇ ਚੈਟ ਦੇ ਵਿਚਕਾਰ ਸਪਲਿਟਰ ਨੂੰ ਖਿੱਚੋ, ਅਤੇ ਟਰਮੀਨਲ ਦਾ ਆਕਾਰ ਬਦਲਣ ਲਈ ਹਰੀਜ਼ੱਟਲ ਸਪਲਿਟਰ ਨੂੰ ਖਿੱਚੋ। ਖੱਬੀ ਸਾਈਡਬਾਰ ਵਰਕਸਪੇਸ, ਐਕਸਟੈਂਸ਼ਨਾਂ, API ਕੁੰਜੀਆਂ, ਬਿਲਿੰਗ, ਅਤੇ ਫੀਡਬੈਕ 'ਤੇ ਵੀ ਨੈਵੀਗੇਟ ਕਰਦੀ ਹੈ।

4 ਇੱਕ ਪ੍ਰੋਜੈਕਟ ਖੋਲ੍ਹਣਾ

4.1 ਇੱਕ ਸਥਾਨਕ ਫੋਲਡਰ ਖੋਲ੍ਹੋ

1. ਐਕਸਪਲੋਰਰ ਵਿੱਚ, ਪ੍ਰੋਜੈਕਟ ਫੋਲਡਰ ਖੋਲ੍ਹੋ 'ਤੇ ਕਲਿੱਕ ਕਰੋ।
2. ਇੱਕ ਫੋਲਡਰ ਚੁਣੋ ਅਤੇ ਬ੍ਰਾਊਜ਼ਰ ਨੂੰ ਇਸਨੂੰ ਪੜ੍ਹਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿਓ।
3. ਫਾਈਲਾਂ ਤੁਹਾਡੇ ਬ੍ਰਾਊਜ਼ਰ ਦੇ ਏਨਕ੍ਰਿਪਟਡ ਇਨ-ਬ੍ਰਾਊਜ਼ਰ ਵਰਕਸਪੇਸ ਵਿੱਚ ਪੜ੍ਹੀਆਂ ਜਾਂਦੀਆਂ ਹਨ — ਕੁਝ ਵੀ ਅੱਪਲੋਡ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ। ਤੁਸੀਂ ਇੱਕ ਲਾਈਵ ਗਿਣਤੀ ਅਤੇ ਇੱਕ ਅੰਤਿਮ ਸੰਖੇਪ ਜਾਣਕਾਰੀ (ਫਾਈਲ ਗਿਣਤੀ · ਆਕਾਰ, ਨਾਲ ਹੀ ਕੋਈ ਵੀ ਛੱਡੀਆਂ ਗਈਆਂ ਜਾਂ ਛੋਟੀਆਂ ਕੀਤੀਆਂ ਫਾਈਲਾਂ) ਦੇਖੋਗੇ।

4.2 Git ਤੋਂ ਖੋਲ੍ਹੋ (GitHub / GitLab)

1. ਐਕਸਪਲੋਰਰ ਵਿੱਚ Git ਤੋਂ ਖੋਲ੍ਹੋ 'ਤੇ ਕਲਿੱਕ ਕਰੋ।
2. GitHub ਜਾਂ GitLab ਟੈਬ ਚੁਣੋ ਅਤੇ ਇੱਕ ਨਿੱਜੀ ਐਕਸੈਸ ਟੋਕਨ ਪੇਸਟ ਕਰੋ। GitHub ਲਈ repo ਸਕੋਪ (ਕਲਾਸਿਕ) ਜਾਂ ਸਮੱਗਰੀ + ਪੁੱਲ ਬੇਨਤੀਆਂ ਦੇ ਨਾਲ ਇੱਕ ਵਧੀਆ-ਗ੍ਰੇਨਡ ਟੋਕਨ ਦੀ ਵਰਤੋਂ ਕਰੋ; GitLab ਲਈ api ਸਕੋਪ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਤੁਹਾਡਾ ਟੋਕਨ ਸਰਵਰ 'ਤੇ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ — ਸਿਰਫ ਫਾਈਲ ਸਮੱਗਰੀ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਖਿੱਚੀ ਜਾਂਦੀ ਹੈ।
3. ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ owner/name ਵਜੋਂ ਟਾਈਪ ਕਰੋ (ਆਪਣੀ ਲੱਭਣ ਲਈ ਸੂਚੀ ਨੂੰ ਫਿਲਟਰ ਕਰੋ), ਫਿਰ ਇੱਕ ਸ਼ਾਖਾ ਚੁਣੋ।
4. ਵਿਕਲਪਿਕ ਤੌਰ 'ਤੇ ਇੱਕ ਨਵੀਂ ਕਾਰਜਕਾਰੀ ਸ਼ਾਖਾ ਬਣਾਓ (ਉਦਾਹਰਨ ਲਈ dcc/my-feature) 'ਤੇ ਨਿਸ਼ਾਨ ਲਗਾਓ ਤਾਂ ਜੋ ਤੁਹਾਡੇ ਕੰਮ ਨੂੰ ਡਿਫੌਲਟ ਸ਼ਾਖਾ ਤੋਂ ਅਲੱਗ ਰੱਖਿਆ ਜਾ ਸਕੇ।
5. ਵਿਕਲਪਿਕ ਤੌਰ 'ਤੇ ਪੁਸ਼ ਵੈਬਹੁੱਕ ਨੂੰ ਸਮਰੱਥ ਬਣਾਓ ਤਾਂ ਜੋ ਟੀਮ ਦੇ ਸਾਥੀ ਪੁਸ਼ ਕਰਨ 'ਤੇ ਐਕਸਪਲੋਰਰ ਤੁਰੰਤ ਰਿਫ੍ਰੈਸ਼ ਹੋ ਜਾਵੇ (ਇੱਕ ਜਨਤਕ ਗੇਟਵੇ URL ਦੀ ਲੋੜ ਹੈ)।
6. ਕਲਿੱਕ ਕਰੋ ਰਿਪੋਜ਼ਟਰੀ ਖੋਲ੍ਹੋ।

4.3 ਰਿਫ੍ਰੈਸ਼ ਕਰੋ, ਸਵਿੱਚ ਕਰੋ, ਅਤੇ ਬੰਦ ਕਰੋ

• ਰਿਫ੍ਰੈਸ਼ (ਐਕਸਪਲੋਰਰ ਹੈਡਰ ਵਿੱਚ ↻) ਫੋਲਡਰ ਨੂੰ ਮੁੜ-ਸਕੈਨ ਕਰਦਾ ਹੈ ਜਾਂ Git ਤੋਂ ਨਵੀਨਤਮ ਖਿੱਚਦਾ ਹੈ।
• ਟ੍ਰੀ ਦੇ ਹੇਠਾਂ ਬਟਨਾਂ ਤੋਂ ਇੱਕ ਹੋਰ ਖੋਲ੍ਹੋ ਫੋਲਡਰ ਜਾਂ Git ਤੋਂ ਖੋਲ੍ਹੋ।
• ਪ੍ਰੋਜੈਕਟ ਬੰਦ ਕਰੋ (ਰੱਦੀ ਆਈਕਨ) ਇਨ-ਬ੍ਰਾਊਜ਼ਰ ਵਰਕਸਪੇਸ ਨੂੰ ਮਿਟਾ ਦਿੰਦਾ ਹੈ।

4.4 ਫੋਲਡਰ-ਸਕੋਪਡ ਚੈਟ ਸੈਸ਼ਨ

ਚੈਟ ਇਤਿਹਾਸ ਖੁੱਲ੍ਹੇ ਪ੍ਰੋਜੈਕਟ ਨਾਲ ਜੁੜਿਆ ਹੋਇਆ ਹੈ। ਫੋਲਡਰ ਬਦਲਣ ਨਾਲ ਆਪਣੇ ਆਪ ਇੱਕ ਨਵਾਂ ਸੈਸ਼ਨ ਸ਼ੁਰੂ ਹੋ ਜਾਂਦਾ ਹੈ ਅਤੇ ਉਸ ਫੋਲਡਰ ਦੇ ਪਿਛਲੇ ਸੈਸ਼ਨ ਲੋਡ ਹੋ ਜਾਂਦੇ ਹਨ, ਸਭ ਤੋਂ ਤਾਜ਼ਾ ਨੂੰ ਦੁਬਾਰਾ ਖੋਲ੍ਹਿਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਜੋ ਤੁਸੀਂ ਉੱਥੋਂ ਜਾਰੀ ਰੱਖ ਸਕੋ ਜਿੱਥੇ ਤੁਸੀਂ ਛੱਡਿਆ ਸੀ।

4.5 ਸੰਚਾਲਨ ਫੋਲਡਰ

DeepCerebra ਅੰਦਰੂਨੀ ਤੌਰ 'ਤੇ ਵਰਤਦਾ ਹੈ — .deepcerebra, .sessions — ਟ੍ਰੀ ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ ਪਰ ਮੂਲ ਰੂਪ ਵਿੱਚ ਸੰਕੁਚਿਤ ਹੁੰਦੇ ਹਨ ਤਾਂ ਜੋ ਉਹ ਤੁਹਾਡੇ ਸਰੋਤ ਨੂੰ ਗੜਬੜ ਨਾ ਕਰਨ।

5 ਫਾਈਲਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ

• ਐਡੀਟਰ ਵਿੱਚ ਖੋਲ੍ਹਣ ਲਈ ਐਕਸਪਲੋਰਰ ਵਿੱਚ ਇੱਕ ਫਾਈਲ 'ਤੇ ਕਲਿੱਕ ਕਰੋ; ਮਿਨੀਮੈਪ ਤੁਹਾਨੂੰ ਲੰਬੀਆਂ ਫਾਈਲਾਂ ਨੂੰ ਨੈਵੀਗੇਟ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।
• ਆਪਣੀ ਅਗਲੀ ਸੁਨੇਹੇ ਲਈ ਸਪਸ਼ਟ ਸੰਦਰਭ ਵਜੋਂ ਨੱਥੀ ਕਰਨ ਲਈ ਐਕਸਪਲੋਰਰ ਤੋਂ ਇੱਕ ਫਾਈਲ ਨੂੰ ਖਿੱਚੋ ਚੈਟ ਪ੍ਰੋਂਪਟ ਵਿੱਚ।
• ਜਦੋਂ ਏਜੰਟ ਸੰਪਾਦਨਾਂ ਦਾ ਪ੍ਰਸਤਾਵ ਕਰਦਾ ਹੈ, ਤਾਂ ਐਡੀਟਰ ਚੁਣੀ ਗਈ ਫਾਈਲ ਲਈ ਇੱਕ ਇਨਲਾਈਨ ਡਿਫ ਦਿਖਾਉਂਦਾ ਹੈ।

6 ਏਜੰਟ ਨਾਲ ਗੱਲਬਾਤ ਕਰਨਾ

ਇੱਕ ਬੇਨਤੀ ਲਿਖੋ

ਸਪਸ਼ਟ ਭਾਸ਼ਾ ਵਿੱਚ ਦੱਸੋ ਕਿ ਤੁਸੀਂ ਕੀ ਚਾਹੁੰਦੇ ਹੋ — ਇੱਕ ਸਵਾਲ ਪੁੱਛੋ, ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਬੇਨਤੀ ਕਰੋ, ਜਾਂ ਇੱਕ ਬੱਗ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰੋ। ਵਧੀਆ ਨਤੀਜਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਫਾਈਲਾਂ, ਫਰੇਮਵਰਕ ਅਤੇ ਸੀਮਾਵਾਂ ਬਾਰੇ ਖਾਸ ਰਹੋ। ਸੰਬੰਧਿਤ ਫਾਈਲਾਂ ਨੂੰ ਪ੍ਰੋਂਪਟ ਵਿੱਚ ਖਿੱਚ ਕੇ ਅਟੈਚ ਕਰੋ।

ਜਵਾਬ ਪੜ੍ਹੋ, Cursor-ਸ਼ੈਲੀ

ਜਵਾਬ Cursor ਵਾਂਗ ਸੰਗਠਿਤ ਕੀਤੇ ਗਏ ਹਨ: ਏਜੰਟ ਦਾ ਤਰਕ ਡਿਲੀਵਰੇਬਲ ਤੋਂ ਵੱਖਰਾ ਹੈ। ਹਰੇਕ ਜਵਾਬ ਬਲਾਕ ਦੇ ਉੱਪਰ-ਸੱਜੇ ਕੋਨੇ ਵਿੱਚ ਇੱਕ ਕਾਪੀ ਆਈਕਨ ਹੁੰਦਾ ਹੈ ਤਾਂ ਜੋ ਤੁਸੀਂ ਇੱਕ ਮੁਕੰਮਲ ਰਿਪੋਰਟ, ਦਸਤਾਵੇਜ਼, ਜਾਂ ਇੱਕ ਕਮਾਂਡ ਦੀ ਨਕਲ ਕਰ ਸਕੋ ਜੋ ਤੁਹਾਨੂੰ ਚਲਾਉਣੀ ਹੈ।

ਇੱਕ ਰਨ ਨੂੰ ਸਟੀਅਰ ਜਾਂ ਰੋਕੋ

• ਇੱਕ ਰਨ ਨੂੰ ਰੋਕਣ ਲਈ ਰੋਕੋ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜੋ ਗਲਤ ਦਿਸ਼ਾ ਵਿੱਚ ਜਾ ਰਿਹਾ ਹੈ, ਫਿਰ ਆਪਣੇ ਪ੍ਰੋਂਪਟ ਨੂੰ ਸੁਧਾਰੋ।
• ਏਜੰਟ ਨੂੰ ਇੱਕ ਲੂਪ ਤੋਂ ਬਾਹਰ ਕੱਢਣ ਲਈ ਸੰਕੇਤ ਦਿਓ (ਉਦਾਹਰਨ ਲਈ "lxml ਦੀ ਬਜਾਏ html.parser ਦੀ ਵਰਤੋਂ ਕਰੋ")।

7 ਚਾਰ ਚੈਟ ਮੋਡ

ਪ੍ਰੋਂਪਟ ਦੇ ਅੱਗੇ ਮੋਡ ਸਿਲੈਕਟਰ ਤੋਂ ਇੱਕ ਮੋਡ ਚੁਣੋ। ਹਰ ਇੱਕ ਇਹ ਟਿਊਨ ਕਰਦਾ ਹੈ ਕਿ ਏਜੰਟ ਕਿੰਨੀ ਯੋਜਨਾ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਕਿੰਨੀ ਸੁਤੰਤਰਤਾ ਨਾਲ ਸੰਪਾਦਿਤ ਕਰਦਾ ਹੈ:

8 ਤਬਦੀਲੀਆਂ ਦੀ ਸਮੀਖਿਆ ਕਰਨਾ ਅਤੇ ਲਾਗੂ ਕਰਨਾ

ਜਦੋਂ ਏਜੰਟ ਫਾਈਲ ਤਬਦੀਲੀਆਂ ਦਾ ਪ੍ਰਸਤਾਵ ਕਰਦਾ ਹੈ, ਤਾਂ ਚੈਟ ਇਨਪੁਟ ਦੇ ਉੱਪਰ ਇੱਕ ਪ੍ਰਸਤਾਵਿਤ ਤਬਦੀਲੀਆਂ ਪੈਨਲ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਹਰੇਕ ਛੂਹੀ ਗਈ ਫਾਈਲ ਨੂੰ ਜੋੜੀਆਂ ਗਈਆਂ (+) ਅਤੇ ਹਟਾਈਆਂ ਗਈਆਂ (−) ਲਾਈਨਾਂ ਦੀ ਗਿਣਤੀ ਦੇ ਨਾਲ ਸੂਚੀਬੱਧ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

• ਐਡੀਟਰ ਵਿੱਚ ਇਸਦੇ ਇਨਲਾਈਨ ਡਿਫ ਨੂੰ ਖੋਲ੍ਹਣ ਲਈ ਇੱਕ ਫਾਈਲ ਕਤਾਰ 'ਤੇ ਕਲਿੱਕ ਕਰੋ।
• ਲਾਗੂ ਕਰੋ ਜਾਂ ਰੱਦ ਕਰੋ ਇੱਕ ਸਿੰਗਲ ਫਾਈਲ, ਜਾਂ ਵਰਤੋ ਸਾਰੇ ਲਾਗੂ ਕਰੋ / ਸਾਰੇ ਰੱਦ ਕਰੋ।
• ਲਾਗੂ ਕੀਤੀਆਂ ਤਬਦੀਲੀਆਂ ਨੂੰ applied (ਅਤੇ · disk ਜਦੋਂ ਇੱਕ ਅਸਲ ਫੋਲਡਰ ਵਿੱਚ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ) ਵਜੋਂ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
• ਜੇਕਰ ਕੋਈ ਲਿਖਣਯੋਗ ਫੋਲਡਰ ਨਹੀਂ ਹੈ, ਤਾਂ ਇੱਕ ਸਿਰਫ ਵਰਕਸਪੇਸ ਬੈਜ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਤਬਦੀਲੀਆਂ ਇਨ-ਬ੍ਰਾਊਜ਼ਰ ਵਰਕਸਪੇਸ 'ਤੇ ਲਾਗੂ ਹੁੰਦੀਆਂ ਹਨ।

9 ਏਕੀਕ੍ਰਿਤ ਟਰਮੀਨਲ

ਬਿਲਡ, ਟੈਸਟ, ਅਤੇ ਸਕ੍ਰਿਪਟਾਂ ਚਲਾਉਣ ਲਈ ਐਡੀਟਰ ਦੇ ਹੇਠਾਂ ਟਰਮੀਨਲ ਨੂੰ ਟੌਗਲ ਕਰੋ। ਤੁਹਾਡੀ ਅਧਿਕਾਰਤਤਾ ਨਾਲ, ਏਜੰਟ ਕਮਾਂਡਾਂ ਨੂੰ ਚਲਾ ਸਕਦਾ ਹੈ ਅਤੇ ਆਪਣੇ ਕੰਮ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ ਉਹਨਾਂ ਦੀ ਆਉਟਪੁੱਟ ਨੂੰ ਪੜ੍ਹ ਸਕਦਾ ਹੈ; ਲੰਬੇ ਸਮੇਂ ਤੱਕ ਚੱਲਣ ਵਾਲੀਆਂ ਕਮਾਂਡਾਂ ਆਉਟਪੁੱਟ ਨੂੰ ਸਟ੍ਰੀਮ ਕਰਦੀਆਂ ਹਨ ਤਾਂ ਜੋ ਤੁਸੀਂ ਪ੍ਰਗਤੀ ਦੇਖ ਸਕੋ। ਜਦੋਂ ਤੁਹਾਨੂੰ ਇਸਦੀ ਲੋੜ ਨਾ ਹੋਵੇ ਤਾਂ ਇਸਦੇ ਹੈਡਰ ਤੋਂ ਟਰਮੀਨਲ ਨੂੰ ਬੰਦ ਕਰੋ।

10 ਪਲਾਨ ਮੋਡ ਅਤੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ

ਵੱਡੇ ਟੀਚਿਆਂ ਲਈ, ਪਲਾਨ ਮੋਡ ਦੀ ਵਰਤੋਂ ਕਰੋ (ਜਾਂ ਏਜੰਟ ਨੂੰ ਪਹਿਲਾਂ ਯੋਜਨਾ ਬਣਾਉਣ ਲਈ ਕਹੋ)। ਯੋਜਨਾਕਾਰ ਤੁਹਾਡੇ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਸਕੈਨ ਕਰਦਾ ਹੈ, ਟੀਚੇ ਨੂੰ ਨਿਰਭਰਤਾ-ਜਾਗਰੂਕ ਕਾਰਜਾਂ ਵਿੱਚ ਵੰਡਦਾ ਹੈ, ਅਤੇ ਹਰੇਕ ਨੂੰ ਸਹੀ ਮਾਹਰ (ਆਰਕੀਟੈਕਟ, ਕੋਡਰ, ਟੈਸਟਰ, ਡੌਕਸ) ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ।

• ਯੋਜਨਾ ਦੀ ਸਮੀਖਿਆ ਅਤੇ ਸੰਪਾਦਨ ਕਰੋ — ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਤੋਂ ਪਹਿਲਾਂ ਕਾਰਜਾਂ ਨੂੰ ਜੋੜੋ, ਹਟਾਓ, ਜਾਂ ਸੋਧੋ।
• ਪਰਤ ਦਰ ਪਰਤ ਚਲਾਓ — ਸੁਤੰਤਰ ਕਾਰਜ ਇਕੱਠੇ ਚੱਲਦੇ ਹਨ; ਯੋਜਨਾਕਾਰ ਮੁੜ ਯੋਜਨਾ ਬਣਾ ਸਕਦਾ ਹੈ ਜੇ ਕੋਈ ਕਾਰਜ ਅਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ।
• ਕਿਸੇ ਵੀ ਸਮੇਂ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਰੋਕੋ, ਮੁੜ ਸ਼ੁਰੂ ਕਰੋ, ਜਾਂ ਰੱਦ ਕਰੋ।

11 ਮਾਡਲ ਚੁਣਨਾ ਅਤੇ ਆਟੋ

ਪ੍ਰੋਂਪਟ ਦੇ ਅੱਗੇ ਮਾਡਲ ਪਿਕਰ ਖੋਲ੍ਹੋ। ਵਿਕਲਪਾਂ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਸਮੂਹਬੱਧ ਕੀਤਾ ਗਿਆ ਹੈ:

• ਆਟੋ — DeepCerebra ਨੂੰ ਸਭ ਤੋਂ ਵਧੀਆ ਉਪਲਬਧ ਮਾਡਲ ਚੁਣਨ ਦਿਓ (ਸਿਫਾਰਸ਼ੀ)।
• ਸਥਾਨਕ (ਤੁਹਾਡਾ GPU) — ਤੁਹਾਡੀ ਆਪਣੀ ਮਸ਼ੀਨ ਤੋਂ ਸੇਵਾ ਕੀਤੇ ਮਾਡਲ (ਦੇਖੋ §13)।
• ਪਲੇਟਫਾਰਮ ਗੇਟਵੇ — ਹੋਸਟ ਕੀਤੇ ਮਾਡਲ, ਗੇਟਵੇ ਦੁਆਰਾ ਅਤੇ ਫਿਰ ਵਿਕਰੇਤਾ ਦੁਆਰਾ ਸਮੂਹਬੱਧ (ਉਦਾਹਰਨ ਲਈ Anthropic, OpenAI, Google)।

ਆਟੋ ਚੋਣ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀ ਹੈ

ਆਟੋ 'ਤੇ, DeepCerebra ਟੀਅਰਡ, ਅਡੈਪਟਿਵ ਰੂਟਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ: ਸਧਾਰਨ ਕਾਰਜ ਇੱਕ ਤੇਜ਼, ਕਿਫ਼ਾਇਤੀ ਮਾਡਲ 'ਤੇ ਜਾਂਦੇ ਹਨ, ਜਦੋਂ ਕਿ ਗੁੰਝਲਦਾਰ ਜਾਂ ਯੋਜਨਾ-ਭਾਰੀ ਕੰਮ (ਉਦਾਹਰਨ ਲਈ, ਪਲਾਨ ਮੋਡ) ਇੱਕ ਮਜ਼ਬੂਤ ਮਾਡਲ 'ਤੇ ਰੂਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਲਾਗਤ ਅਤੇ ਗੁਣਵੱਤਾ ਨੂੰ ਆਪਣੇ ਆਪ ਸੰਤੁਲਿਤ ਕਰਦਾ ਹੈ, ਇਸਲਈ ਤੁਹਾਨੂੰ ਹੱਥੀਂ ਚੁਣਨ ਦੀ ਘੱਟ ਹੀ ਲੋੜ ਪੈਂਦੀ ਹੈ।

12 ਆਪਣੀ ਖੁਦ ਦੀ ਕੁੰਜੀ ਲਿਆਓ (BYOK)

ਤੁਸੀਂ ਮੀਟਰਡ ਪਲੇਟਫਾਰਮ ਵਰਤੋਂ ਦੀ ਬਜਾਏ ਆਪਣੇ ਖੁਦ ਦੇ ਪ੍ਰਦਾਤਾ ਖਾਤੇ ਰਾਹੀਂ ਬੇਨਤੀਆਂ ਨੂੰ ਰੂਟ ਕਰ ਸਕਦੇ ਹੋ।

1. ਸਾਈਡਬਾਰ ਤੋਂ API ਕੁੰਜੀਆਂ ਖੋਲ੍ਹੋ।
2. ਆਪਣੀ ਖੁਦ ਦੀ ਕੁੰਜੀ ਲਿਆਓ ਦੇ ਤਹਿਤ, ਇੱਕ ਪ੍ਰਦਾਤਾ ਚੁਣੋ (ਉਦਾਹਰਨ ਲਈ ANTHROPIC_API_KEY, GOOGLE_API_KEY, OPENAI_API_KEY)।
3. ਕੁੰਜੀ ਮੁੱਲ ਪੇਸਟ ਕਰੋ ਅਤੇ ਸੇਵ ਕਰੋ 'ਤੇ ਕਲਿੱਕ ਕਰੋ। ਕੁੰਜੀਆਂ ਆਰਾਮ 'ਤੇ ਏਨਕ੍ਰਿਪਟ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਅਤੇ ਕਦੇ ਵੀ ਬ੍ਰਾਊਜ਼ਰ ਨੂੰ ਵਾਪਸ ਨਹੀਂ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ — ਸਿਰਫ ਇੱਕ ਮਾਸਕਡ ਪ੍ਰੀਵਿਊ ਦਿਖਾਇਆ ਜਾਂਦਾ ਹੈ।

ਪਲੇਟਫਾਰਮ (DeepCerebra) ਮਾਡਲਾਂ ਨੂੰ ਕਿਸੇ ਕੁੰਜੀ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਹਟਾਓ ਨਾਲ ਕਿਸੇ ਵੀ ਸਮੇਂ ਇੱਕ ਕੁੰਜੀ ਹਟਾਓ।

13 ਸਥਾਨਕ ਮਸ਼ੀਨ: GPU ਮਾਡਲ ਅਤੇ ਕੰਸੋਲ (DCC Bridge)

DCC Bridge ਤੁਹਾਡੇ ਆਪਣੇ ਕੰਪਿਊਟਰ ਨੂੰ ਇੱਕ ਛੋਟੇ dcc-bridge ਕਨੈਕਟਰ ਰਾਹੀਂ ਵੈੱਬ ਐਪ ਨਾਲ ਜੋੜਦਾ ਹੈ, ਇੱਕੋ ਸਮੇਂ ਦੋ ਸਮਰੱਥਾਵਾਂ ਨੂੰ ਅਨਲੌਕ ਕਰਦਾ ਹੈ:

• ਸਥਾਨਕ GPU ਮਾਡਲ — ਤੁਹਾਡੀ ਮਸ਼ੀਨ 'ਤੇ Ollama ਜਾਂ LM Studio ਦੁਆਰਾ ਸੇਵਾ ਕੀਤੇ ਮਾਡਲ ਸਥਾਨਕ (ਤੁਹਾਡਾ GPU) ਦੇ ਅਧੀਨ ਮਾਡਲ ਪਿਕਰ ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ।
• ਤੁਹਾਡੀ ਮਸ਼ੀਨ 'ਤੇ ਕੰਸੋਲ / ਟਰਮੀਨਲ — ਵੈੱਬ ਟਰਮੀਨਲ ਅਤੇ ਏਜੰਟ ਤੁਹਾਡੇ ਕੰਪਿਊਟਰ 'ਤੇ ਅਸਲ ਕਮਾਂਡਾਂ ਚਲਾ ਸਕਦੇ ਹਨ, ਜਿਸ ਵਿੱਚ CLI ਟੂਲ ਸ਼ਾਮਲ ਹਨ ਜੋ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਕੌਂਫਿਗਰ ਕੀਤੇ ਹਨ (Railway, AWS CLI, OVH CLI, gh, docker, kubectl, WSL, …) ਉਹਨਾਂ ਦੇ ਮੌਜੂਦਾ ਪ੍ਰਮਾਣ ਪੱਤਰਾਂ ਨਾਲ।

ਕਨੈਕਟਰ ਇੱਕ ਪ੍ਰਮਾਣਿਤ ਵੈੱਬਸਾਕੇਟ ਉੱਤੇ ਬਾਹਰ ਡਾਇਲ ਕਰਦਾ ਹੈ — ਕਿਸੇ ਇਨਬਾਉਂਡ ਪੋਰਟ ਦੀ ਲੋੜ ਨਹੀਂ, ਅਤੇ ਇਹ NAT ਅਤੇ ਫਾਇਰਵਾਲਾਂ ਦੇ ਪਿੱਛੇ ਕੰਮ ਕਰਦਾ ਹੈ। ਇਹ Windows, macOS, ਅਤੇ Linux (Python 3.10+) 'ਤੇ ਚੱਲਦਾ ਹੈ।

13.1 ਆਪਣੇ ਕੰਪਿਊਟਰ ਨੂੰ ਜੋੜੋ

1. ਖੱਬੀ ਗਤੀਵਿਧੀ ਰੇਲ ਵਿੱਚ ਲੈਪਟਾਪ ਆਈਕਨ 'ਤੇ ਕਲਿੱਕ ਕਰੋ — ਸਥਾਨਕ ਮਸ਼ੀਨ (GPU + ਕੰਸੋਲ)। (ਉਹੀ ਪੈਨਲ ਮਾਡਲ ਪਿਕਰ ਫੁੱਟਰ ਤੋਂ ਸਥਾਨਕ GPU ਪ੍ਰਬੰਧਿਤ ਕਰੋ… ਰਾਹੀਂ ਖੁੱਲ੍ਹਦਾ ਹੈ।)
2. ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਸਥਾਨਕ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਟੌਗਲ ਸਮਰੱਥ ਹੈ, ਡਿਵਾਈਸ ਦਾ ਨਾਮ ਦਿਓ, ਅਤੇ ਕਲਿੱਕ ਕਰੋ ਇਸ ਕੰਪਿਊਟਰ ਨੂੰ ਸ਼ਾਮਲ ਕਰੋ। ਇੱਕ ਵਾਰੀ ਵਾਲਾ ਪੇਅਰਿੰਗ ਟੋਕਨ (dcc_brg_…) ਅਤੇ ਤਿਆਰ-ਟੂ-ਪੇਸਟ ਕਨੈਕਟਰ ਕਮਾਂਡ ਨੂੰ ਕਾਪੀ ਕਰੋ — ਟੋਕਨ ਸਿਰਫ਼ ਇੱਕ ਵਾਰ ਦਿਖਾਇਆ ਜਾਂਦਾ ਹੈ।

13.2 ਕਨੈਕਟਰ ਨੂੰ ਸਥਾਪਿਤ ਅਤੇ ਚਲਾਓ

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_xxxxx

• ਗੇਟਵੇ ਵਜੋਂ ਉਹੀ ਡੋਮੇਨ ਵਰਤੋ ਜੋ ਤੁਸੀਂ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਵਰਤਦੇ ਹੋ (wss://deepcerebra.ai ਜਾਂ wss://deepcerebra.io) — ਪੇਅਰਿੰਗ ਕਾਰਡ ਸਹੀ ਨੂੰ ਪਹਿਲਾਂ ਤੋਂ ਭਰਦਾ ਹੈ। ਦੋ ਸਾਈਟਾਂ ਵੱਖਰੇ ਖਾਤਿਆਂ ਅਤੇ ਟੋਕਨਾਂ ਨਾਲ ਵੱਖਰੇ ਤੈਨਾਤੀਆਂ ਹਨ।
• GPU ਮਾਡਲਾਂ ਲਈ, Ollama ਨੂੰ ਚੱਲਦਾ ਰੱਖੋ, ਜਾਂ LM Studio ਦੇ ਸਥਾਨਕ ਸਰਵਰ (ਡਿਫੌਲਟ ਪੋਰਟ 1234) ਨੂੰ ਇੱਕ ਲੋਡ ਕੀਤੇ ਮਾਡਲ ਨਾਲ ਸਮਰੱਥ ਬਣਾਓ।
• ਜੋੜੇ ਗਏ ਡਿਵਾਈਸ ਔਨਲਾਈਨ/ਔਫਲਾਈਨ ਸਥਿਤੀ, ਮਾਡਲ ਗਿਣਤੀ, ਅਤੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਸਕੋਪ ਦਿਖਾਉਂਦੇ ਹਨ; ਤੁਸੀਂ ਕਿਸੇ ਵੀ ਸਮੇਂ ਇੱਕ ਡਿਵਾਈਸ ਨੂੰ ਰੱਦ ਕਰ ਸਕਦੇ ਹੋ।

13.3 ਵੈੱਬ ਐਪ ਤੋਂ ਆਪਣਾ ਕੰਸੋਲ ਵਰਤੋ

ਮੂਲ ਰੂਪ ਵਿੱਚ, ਕਮਾਂਡਾਂ ਇੱਕ ਸਮਰਪਿਤ ਵਰਕਸਪੇਸ ਫੋਲਡਰ ਤੱਕ ਸੀਮਤ ਹੁੰਦੀਆਂ ਹਨ (~/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

ਫਿਰ ਟਰਮੀਨਲ ਪੈਨਲ ਖੋਲ੍ਹੋ, ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਟਾਰਗੇਟ ਪੌਪਓਵਰ (ਲੈਪਟਾਪ ਆਈਕਨ) 'ਤੇ ਕਲਿੱਕ ਕਰੋ, ਮੇਰਾ ਕੰਪਿਊਟਰ ਚੁਣੋ, ਅਤੇ ਇੱਕ ਕਾਰਜਕਾਰੀ ਡਾਇਰੈਕਟਰੀ ਚੁਣੋ। ਤੁਹਾਡੀਆਂ ਟਾਈਪ ਕੀਤੀਆਂ ਕਮਾਂਡਾਂ ਅਤੇ ਏਜੰਟ ਦੀਆਂ ਬਿਲਡ/ਟੈਸਟ ਕਮਾਂਡਾਂ ਦੋਵੇਂ ਫਿਰ ਤੁਹਾਡੀ ਮਸ਼ੀਨ 'ਤੇ ਚਲਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ।

14 Git ਸਹਿਯੋਗ ਵਰਕਫਲੋ

ਇੱਕ Git-ਬੈਕਡ ਪ੍ਰੋਜੈਕਟ ਖੁੱਲ੍ਹਣ 'ਤੇ, ਐਕਸਪਲੋਰਰ ਵਿੱਚ ਇੱਕ ਬ੍ਰਾਂਚ ਬਾਰ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ ਜੋ ਤੁਹਾਡੀ ਮੌਜੂਦਾ ਬ੍ਰਾਂਚ ਅਤੇ ਦੋ ਕਾਰਵਾਈਆਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ:

• ਚੈੱਕ ਇਨ (ਕਮਿਟ) — ਬਦਲੀਆਂ ਗਈਆਂ ਫਾਈਲਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਸਮੀਖਿਆ ਕਰੋ, ਇੱਕ ਕਮਿਟ ਸੁਨੇਹਾ ਲਿਖੋ, ਅਤੇ ਆਪਣੀ ਕਾਰਜਕਾਰੀ ਬ੍ਰਾਂਚ ਵਿੱਚ ਕਮਿਟ ਕਰੋ।
• ਏਕੀਕ੍ਰਿਤ ਕਰੋ — ਆਪਣੀ ਕਾਰਜਕਾਰੀ ਬ੍ਰਾਂਚ ਤੋਂ ਡਿਫੌਲਟ ਬ੍ਰਾਂਚ ਵਿੱਚ ਇੱਕ ਪੁੱਲ ਬੇਨਤੀ ਖੋਲ੍ਹੋ (ਉਦਾਹਰਨ ਲਈ main)। ਤੁਹਾਨੂੰ ਇੱਕ ਕਾਰਜਕਾਰੀ ਬ੍ਰਾਂਚ 'ਤੇ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਨਾ ਕਿ ਡਿਫੌਲਟ ਬ੍ਰਾਂਚ 'ਤੇ।

ਜੇਕਰ ਪੁਸ਼ ਵੈਬਹੁੱਕ ਸਮਰੱਥ ਹੈ, ਤਾਂ ਟੀਮ ਦੇ ਸਾਥੀ ਪੁਸ਼ ਕਰਨ 'ਤੇ ਐਕਸਪਲੋਰਰ ਆਪਣੇ ਆਪ ਰਿਫ੍ਰੈਸ਼ ਹੋ ਜਾਂਦਾ ਹੈ, ਸਾਰਿਆਂ ਨੂੰ ਸਿੰਕ ਵਿੱਚ ਰੱਖਦਾ ਹੈ — DeepCerebra ਰਾਹੀਂ ਸਹਿਯੋਗੀ ਟੀਮ ਵਿਕਾਸ ਲਈ ਬੁਨਿਆਦ।

15 MCP ਸਰਵਰ

ਮਾਡਲ ਸੰਦਰਭ ਪ੍ਰੋਟੋਕੋਲ ਰਾਹੀਂ ਏਜੰਟ ਨੂੰ ਬਾਹਰੀ ਟੂਲ ਅਤੇ ਡੇਟਾ ਨਾਲ ਵਧਾਓ। .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 ਸੂਚੀਬੱਧ ਕਰਦਾ ਹੈ, ਤਾਂ ਸਿਰਫ ਉਹ ਟੂਲ ਚੱਲ ਸਕਦੇ ਹਨ।
• ਉੱਚ-ਜੋਖਮ ਵਾਲੇ ਟੂਲਜ਼ ਲਈ ਮਨਜ਼ੂਰੀ — ਬਦਲਣ ਵਾਲੇ ਟੂਲਜ਼ (write/delete/deploy/…) ਨੂੰ ਮਨਜ਼ੂਰੀ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ 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"
}

16 ਏਜੰਟ ਨੂੰ ਅਨੁਕੂਲਿਤ ਕਰਨਾ: ਨਿਯਮ, ਹੁਨਰ, ਹੁੱਕ, ਸਬਏਜੰਟ ਅਤੇ ਪਲੱਗਇਨ

ਤੁਸੀਂ ਇੱਕ ਸਿੰਗਲ, ਫਾਈਲ-ਅਧਾਰਿਤ ਸੰਮੇਲਨ — .deepcerebra/ ਡਾਇਰੈਕਟਰੀ — ਨਾਲ ਏਜੰਟ ਦੇ ਸੋਚਣ ਅਤੇ ਕੰਮ ਕਰਨ ਦੇ ਤਰੀਕੇ ਨੂੰ ਆਕਾਰ ਦੇ ਸਕਦੇ ਹੋ ਜੋ ਡੈਸਕਟਾਪ ਐਪ, ਵੈੱਬ ਐਪ, ਅਤੇ API ਵਿੱਚ ਇੱਕੋ ਜਿਹਾ ਕੰਮ ਕਰਦਾ ਹੈ। ਵੈੱਬ ਐਪ ਵਿੱਚ, ਇਹਨਾਂ ਸਾਰਿਆਂ ਨੂੰ ਏਜੰਟ ਦ੍ਰਿਸ਼ ਦੇ ਅਧੀਨ ਪ੍ਰਬੰਧਿਤ ਕਰੋ; ਡੈਸਕਟਾਪ 'ਤੇ ਅਤੇ API ਰਾਹੀਂ ਉਹ ਸਧਾਰਨ ਫਾਈਲਾਂ ਹਨ ਜੋ ਤੁਸੀਂ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਨਾਲ ਕਮਿਟ ਕਰਦੇ ਹੋ।

ਸਕੋਪ ਅਤੇ ਪ੍ਰਮੁੱਖਤਾ

ਕੌਨਫਿਗਰੇਸ਼ਨ ਕਈ ਸਕੋਪਾਂ ਤੋਂ ਖੋਜੀ ਜਾਂਦੀ ਹੈ; ਜਦੋਂ ਇੱਕੋ ਆਈਟਮ ਇੱਕ ਤੋਂ ਵੱਧ ਵਿੱਚ ਮੌਜੂਦ ਹੁੰਦੀ ਹੈ, ਉੱਚ-ਤਰਜੀਹ ਵਾਲੀ ਜਿੱਤਦੀ ਹੈ:

team/org  <  global (~/.deepcerebra)  <  workspace (<repo>/.deepcerebra)
(ਸਭ ਤੋਂ ਘੱਟ)                                              (ਸਭ ਤੋਂ ਵੱਧ)

• ਵਰਕਸਪੇਸ — <repo>/.deepcerebra/…, ਪ੍ਰੋਜੈਕਟ ਨਾਲ ਕਮਿਟ ਕੀਤਾ ਗਿਆ।
• ਗਲੋਬਲ — ~/.deepcerebra/…, ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ ਤੁਹਾਡੀਆਂ ਨਿੱਜੀ ਡਿਫੌਲਟ ਸੈਟਿੰਗਾਂ।
• ਟੀਮ / ਸੰਗਠਨ — ਇੱਕ ਸਾਂਝੀ ਬੇਸਲਾਈਨ (ਸਭ ਤੋਂ ਘੱਟ ਪ੍ਰਮੁੱਖਤਾ) ਤਾਂ ਜੋ ਇੱਕ ਉਪਭੋਗਤਾ ਜਾਂ ਪ੍ਰੋਜੈਕਟ ਹਮੇਸ਼ਾ ਇਸਨੂੰ ਓਵਰਰਾਈਡ ਕਰ ਸਕੇ। ਵੈੱਬ ਐਪ ਵਿੱਚ, ਇੱਕ ਨਿਯਮ ਦੇ ਸਕੋਪ ਨੂੰ ਟੀਮ 'ਤੇ ਸੈੱਟ ਕਰੋ।

ਨਿਯਮ (ਸਟੀਅਰਿੰਗ)

ਨਿਯਮ ਸਥਾਈ ਨਿਰਦੇਸ਼ ਹਨ — ਕੋਡਿੰਗ ਮਾਪਦੰਡ, ਆਰਕੀਟੈਕਚਰ ਸੰਮੇਲਨ, ਡੋਮੇਨ ਸੰਦਰਭ — ਜੋ ਏਜੰਟ ਦੇ ਸਿਸਟਮ ਪ੍ਰੋਂਪਟ ਵਿੱਚ ਇੰਜੈਕਟ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਉਹ .deepcerebra/steering/ ਦੇ ਅਧੀਨ Markdown ਫਾਈਲਾਂ ਵਜੋਂ ਰਹਿੰਦੇ ਹਨ, ਨਾਲ ਹੀ ਹਮੇਸ਼ਾ ਚਾਲੂ AGENTS.md ਸਟੈਂਡਰਡ। ਫਰੰਟਮੈਟਰ ਨਿਯੰਤਰਿਤ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਨਿਯਮ ਕਦੋਂ ਲੋਡ ਹੁੰਦਾ ਹੈ:

---
inclusion: fileMatch          # always | fileMatch | auto | manual
globs: "src/**/*.ts"          # or fileMatchPattern
name: api-design
description: REST conventions
---
# API design
- Use REST resource nouns, plural.

• always — ਹਰ ਵਾਰੀ (ਡਿਫੌਲਟ)।
• fileMatch — ਸਿਰਫ ਉਦੋਂ ਜਦੋਂ ਇੱਕ ਇਨ-ਕੰਟੈਕਸਟ ਫਾਈਲ globs ਨਾਲ ਮੇਲ ਖਾਂਦੀ ਹੈ।
• auto — ਜਦੋਂ ਤੁਹਾਡੀ ਬੇਨਤੀ ਨਿਯਮ ਦੇ name/description ਨਾਲ ਮੇਲ ਖਾਂਦੀ ਹੈ।
• manual — ਸਿਰਫ ਉਦੋਂ ਜਦੋਂ ਤੁਸੀਂ ਇਸਨੂੰ #name ਜਾਂ /name ਵਜੋਂ ਸੰਦਰਭਿਤ ਕਰਦੇ ਹੋ।

ਇੱਕ ਰੂਟ AGENTS.md ਰੈਪੋ-ਵਿਆਪਕ ਲਾਗੂ ਹੁੰਦਾ ਹੈ; ਇੱਕ ਨੈਸਟਡ AGENTS.md (ਉਦਾਹਰਨ ਲਈ, services/api/AGENTS.md) ਸਿਰਫ਼ ਉਸ ਫੋਲਡਰ ਦੇ ਅਧੀਨ ਫਾਈਲਾਂ 'ਤੇ ਲਾਗੂ ਹੁੰਦਾ ਹੈ। ਵੈੱਬ ਐਪ ਵਿੱਚ, Agent → Steering ਵਿਊ ਹਰੇਕ ਨਿਯਮ ਨੂੰ ਇੱਕ Scope ਪਿਕਰ ਦਿੰਦਾ ਹੈ (Global / Project / Team)।

ਹੁਨਰ

ਹੁਨਰ ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਪਲੇਬੁੱਕ ਹਨ ਜੋ ਏਜੰਟ ਮੰਗ 'ਤੇ ਲੋਡ ਕਰਦਾ ਹੈ। ਹਰੇਕ ਹੁਨਰ .deepcerebra/skills/ ਦੇ ਅਧੀਨ ਇੱਕ SKILL.md ਵਾਲਾ ਇੱਕ ਫੋਲਡਰ ਹੈ:

---
name: deploy-release
description: How to cut and publish a versioned release.
disable-model-invocation: false   # true => manual-only (/skill)
---
# Deploy a release
1. Bump the version, build, and test.
2. Tag and publish.

ਏਜੰਟ ਇੱਕ ਹਲਕਾ ਕੈਟਾਲਾਗ (ਨਾਮ + ਵੇਰਵਾ) ਦੇਖਦਾ ਹੈ ਅਤੇ ਪੂਰੇ ਬੌਡੀ ਨੂੰ ਇਸ ਨਾਲ ਖਿੱਚਦਾ ਹੈ load_skill ਟੂਲ ਨਾਲ ਜਦੋਂ ਸੰਬੰਧਿਤ ਹੋਵੇ। ਤੁਸੀਂ ਇੱਕ ਨੂੰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਇਸ ਨਾਲ ਵੀ ਬੁਲਾ ਸਕਦੇ ਹੋ /skill <name>। ਸੈੱਟ ਕਰੋ disable-model-invocation: true ਇੱਕ ਹੁਨਰ ਨੂੰ ਸਿਰਫ਼ ਮੈਨੂਅਲ ਬਣਾਉਣ ਲਈ।

ਹੁੱਕ

ਹੁੱਕ ਲਾਈਫਸਾਈਕਲ ਇਵੈਂਟਾਂ 'ਤੇ ਆਟੋਮੇਸ਼ਨ ਚਲਾਉਂਦੇ ਹਨ। ਉਹਨਾਂ ਨੂੰ .deepcerebra/hooks/*.hook.json ਵਜੋਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ:

{
  "title": "Format on save",
  "event": "fileSave",
  "filePattern": ["**/*.ts"],
  "action": { "type": "shell", "command": "npm run lint:fix -- $FILE" },
  "enabled": true
}

ਇਵੈਂਟਾਂ ਵਿੱਚ promptSubmit, preToolUse, postToolUse, fileCreate, fileSave, fileDelete, preTask, postTask, sessionStart, preCompact, ਅਤੇ agentStop ਸ਼ਾਮਲ ਹਨ (Cursor/Claude ਸਪੈਲਿੰਗ ਵੀ ਸਵੀਕਾਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ)। ਇੱਕ ਕਾਰਵਾਈ ਜਾਂ ਤਾਂ shell (ਇੱਕ ਕਮਾਂਡ ਚਲਾਓ) ਜਾਂ agentPrompt (ਏਜੰਟ ਨੂੰ ਪੁੱਛੋ) ਹੁੰਦੀ ਹੈ। ਇੱਕ preToolUse ਹੁੱਕ ਉਸ ਟੂਲ ਕਾਲ ਲਈ ਇਜਾਜ਼ਤ, ਅਸਵੀਕਾਰ, ਜਾਂ ਪੁੱਛ ਸਕਦਾ ਹੈ ਜਿਸਨੂੰ ਇਹ ਰੋਕਦਾ ਹੈ।

ਸਬਏਜੰਟ

ਸਬ-ਏਜੰਟ ਵਿਸ਼ੇਸ਼ ਏਜੰਟ ਹੁੰਦੇ ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ ਤੁਸੀਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੇ ਹੋ ਅਤੇ ਕੰਮ ਸੌਂਪਦੇ ਹੋ। ਹਰ ਇੱਕ ਮਾਰਕਡਾਊਨ ਫਾਈਲ ਹੁੰਦੀ ਹੈ .deepcerebra/agents/ ਫਰੰਟਮੈਟਰ ਦੇ ਨਾਲ ਅਤੇ ਇੱਕ ਬੋਡੀ (ਇਸਦਾ ਸਿਸਟਮ ਪ੍ਰੋਂਪਟ):

---
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 ਮਾਰਕਰ ਫਾਈਲ ਨਾਲ ਅਯੋਗ ਕਰੋ।

17 ਏਜੰਟਿਕ ਵਰਕਫਲੋ ਸਟੂਡੀਓ ਅਤੇ ਇਵੈਂਟ-ਡ੍ਰਾਈਵਨ ਏਜੰਟ

ਵਰਕਫਲੋ ਸਟੂਡੀਓ ਮਲਟੀ-ਏਜੰਟ ਆਟੋਮੇਸ਼ਨ ਲਈ ਇੱਕ ਵਿਜ਼ੂਅਲ ਡਿਜ਼ਾਈਨਰ ਹੈ। ਤੁਸੀਂ ਸਟੇਜਾਂ — ਹਰੇਕ ਇੱਕ ਏਜੰਟ, ਇੱਕ ਮਾਹਰ ਕਦਮ, ਜਾਂ ਇੱਕ ਕੰਟਰੋਲ ਪ੍ਰਿਮਿਟਿਵ — ਨੂੰ ਇੱਕ ਗ੍ਰਾਫ ਵਿੱਚ ਕੰਪੋਜ਼ ਕਰਦੇ ਹੋ, ਉਹਨਾਂ ਨੂੰ ਨਿਰਭਰਤਾਵਾਂ ਨਾਲ ਜੋੜਦੇ ਹੋ, ਅਤੇ ਲਾਈਵ ਪ੍ਰਤੀ-ਸਟੇਜ ਪ੍ਰਗਤੀ, ਬਜਟ, ਅਤੇ ਮਨੁੱਖੀ-ਪ੍ਰਵਾਨਗੀ ਗੇਟਾਂ ਦੇ ਨਾਲ ਇੰਜਣ 'ਤੇ ਪੂਰੀ ਆਰਕੈਸਟ੍ਰੇਸ਼ਨ ਚਲਾਉਂਦੇ ਹੋ। ਵਰਕਫਲੋ ਇੱਕ ਪੋਰਟੇਬਲ YAML/JSON ਪਰਿਭਾਸ਼ਾ ਵਜੋਂ ਸੁਰੱਖਿਅਤ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਜਿਸਨੂੰ ਤੁਸੀਂ Git ਵਿੱਚ ਨਿਰਯਾਤ, ਆਯਾਤ, ਸੰਸਕਰਣ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ API ਜਾਂ CLI ਤੋਂ ਚਲਾ ਸਕਦੇ ਹੋ।

17.1 ਇੱਕ ਵਰਕਫਲੋ ਬਣਾਉਣਾ

• ਪੈਲੇਟ (ਖੱਬੇ) — ਸਟੇਜ ਕਿਸਮਾਂ, ਤਿਆਰ-ਕੀਤੇ ਏਜੰਟ ਕਿਸਮਾਂ (ਖੋਜ, ਕੋਡ ਜਨਰੇਸ਼ਨ, QA, ਦਸਤਾਵੇਜ਼ ਲੇਖਕ, ਮੈਡੀਕਲ ਡਿਵਾਈਸ, ਪੇਟੈਂਟ ਕਾਉਂਸਲ, ਅਤੇ ਤੁਹਾਡੀਆਂ ਆਪਣੀਆਂ ਕਸਟਮ ਕਿਸਮਾਂ), ਸਕਿੱਲ ਲਾਇਬ੍ਰੇਰੀ ਤੋਂ ਹੁਨਰ, ਅਤੇ ਟੂਲ ਕੈਨਵਸ 'ਤੇ ਖਿੱਚੋ।
• ਕੈਨਵਸ (ਕੇਂਦਰ) — ਸਟੇਜਾਂ ਨੂੰ ਵਿਵਸਥਿਤ ਕਰੋ ਅਤੇ ਕਿਨਾਰੇ ਖਿੱਚੋ; ਇੱਕ ਕਿਨਾਰੇ ਦਾ ਮਤਲਬ ਹੈ "ਇਹ ਸਟੇਜ ਉਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ" ਅਤੇ ਆਪਣੇ ਆਪ ਅੱਪਸਟ੍ਰੀਮ ਆਉਟਪੁੱਟ ਨੂੰ ਡਾਊਨਸਟ੍ਰੀਮ ਪ੍ਰੋਂਪਟ ਵਿੱਚ ਫੀਡ ਕਰਦਾ ਹੈ।
• ਇੰਸਪੈਕਟਰ (ਸੱਜੇ, ਮੁੜ-ਆਕਾਰਯੋਗ) — ਚੁਣੀ ਗਈ ਸਟੇਜ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰੋ: ਇਸਦਾ ਪ੍ਰੋਂਪਟ, ਹੁਨਰ, ਟੂਲ, ਪ੍ਰਤੀ-ਸਟੇਜ ਮਾਡਲ ਓਵਰਰਾਈਡ, ਆਉਟਪੁੱਟ ਆਰਟੀਫੈਕਟ, ਗੇਟ, ਇਵੈਂਟਸ, ਅਤੇ ਕਿਸਮ-ਵਿਸ਼ੇਸ਼ ਪੈਰਾਮੀਟਰ।
• ਟੈਂਪਲੇਟਸ — ਇੱਕ ਬਿਲਟ-ਇਨ ਬਲੂਪ੍ਰਿੰਟ (Ship-It Pipeline, SaaS Starter, Data Pipeline with Evals, Customer Comms Hub, Design → Verified App) ਤੋਂ ਸ਼ੁਰੂ ਕਰੋ ਅਤੇ ਇਸਨੂੰ ਅਨੁਕੂਲਿਤ ਕਰੋ।
• ਤਿਆਰ ਕਰੋ — ਐਪ ਜਾਂ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਧਾਰਨ ਭਾਸ਼ਾ ਵਿੱਚ ਦੱਸੋ ਅਤੇ ਏਜੰਟ ਬਿਲਡਰ ਇੱਕ ਸੰਪੂਰਨ, ਪ੍ਰਮਾਣਿਤ ਵਰਕਫਲੋ ਗ੍ਰਾਫ ਤਿਆਰ ਕਰਦਾ ਹੈ ਜਿਸਦੀ ਤੁਸੀਂ ਸਮੀਖਿਆ, ਵਿਵਸਥਿਤ ਅਤੇ ਚਲਾ ਸਕਦੇ ਹੋ।

17.2 ਸਟੇਜ ਲਾਇਬ੍ਰੇਰੀ

17.3 ਇਵੈਂਟ-ਡ੍ਰਾਈਵਨ ਏਜੰਟ (ਏਜੰਟ ਮੈਸ਼)

ਹਰੇਕ ਸਟੇਜ — ਕਿਸਮ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ — ਵਰਕਸਪੇਸ ਇਵੈਂਟ ਬੱਸ 'ਤੇ ਟਾਈਪ ਕੀਤੇ ਇਵੈਂਟਾਂ ਨੂੰ ਪ੍ਰਕਾਸ਼ਿਤ ਅਤੇ ਸਬਸਕ੍ਰਾਈਬ ਕਰ ਸਕਦੀ ਹੈ, ਇਸਲਈ ਏਜੰਟ DAG ਰਾਹੀਂ ਹੀ ਨਹੀਂ ਬਲਕਿ ਇੱਕ ਸੁਨੇਹਾ ਫੈਬਰਿਕ 'ਤੇ ਸੇਵਾਵਾਂ ਵਾਂਗ ਤਾਲਮੇਲ ਕਰਦੇ ਹਨ:

• ਘਟਨਾ ਸ਼੍ਰੇਣੀਆਂ — ਹਰ ਘਟਨਾ ਦੀ ਇੱਕ ਸ਼੍ਰੇਣੀ ਹੁੰਦੀ ਹੈ: lifecycle, agent, business, data, system, schedule, chat, external, or alert — ਸਬਸਕ੍ਰਿਪਸ਼ਨਾਂ ਅਤੇ ਰੀਪਲੇਅ ਵਿੱਚ ਫਿਲਟਰ ਕਰਨ ਯੋਗ।
• ਸਬਸਕ੍ਰਾਈਬ ਮੋਡ — trigger (ਸਟੇਜ ਉਦੋਂ ਚੱਲਦੀ ਹੈ ਜਦੋਂ ਇੱਕ ਮੇਲ ਖਾਂਦਾ ਇਵੈਂਟ ਆਉਂਦਾ ਹੈ; ਪਾਰਕ ਕੀਤੀਆਂ ਸਟੇਜਾਂ ਵਾਲੀ ਇੱਕ ਰਨ ਸੁਣਨ ਵਜੋਂ ਰਹਿੰਦੀ ਹੈ), gate (ਇੱਕ ਮਸ਼ੀਨ ਗੇਟ ਜੋ ਮਨੁੱਖੀ ਕਲਿੱਕ ਦੀ ਬਜਾਏ ਇੱਕ ਇਵੈਂਟ ਦੁਆਰਾ ਪ੍ਰਵਾਨਿਤ ਹੁੰਦਾ ਹੈ), ਅਤੇ data (ਪੇਲੋਡ ਸਟੇਜ ਦੇ ਸੰਦਰਭ ਵਿੱਚ ਮਰਜ ਕੀਤਾ ਜਾਂਦਾ ਹੈ)।
• ਘਟਨਾ ਦੁਆਰਾ ਸ਼ੁਰੂਆਤ — ਕੋਈ ਵੀ ਏਜੰਟ ਇੱਕ ਆਰਕੈਸਟ੍ਰੇਟਰ ਜਾਂ ਕਿਸੇ ਹੋਰ ਏਜੰਟ ਦੁਆਰਾ ਇਸਦੇ ਪਤੇ 'ਤੇ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਕੇ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ agent.<stage-id>.request.
• ਰਨ ਟ੍ਰਿਗਰ — ਇੱਕ ਵਰਕਫਲੋ ਦਾ triggers: ਬਲਾਕ ਇਸਨੂੰ ਇਨਬਾਉਂਡ ਵੈਬਹੁੱਕ, ਕਰੋਨ ਸ਼ਡਿਊਲ, ਇਵੈਂਟਸ, ਜਾਂ ਚੈਟ 'ਤੇ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਤਿਆਰ ਕਰਦਾ ਹੈ — ਭਾਵੇਂ ਸਟੂਡੀਓ ਬੰਦ ਹੋਵੇ।
• ਲਾਈਵ ਰਨ — ਰਨ ਪੈਨਲ SSE 'ਤੇ ਲਾਈਫਸਾਈਕਲ ਇਵੈਂਟਾਂ ਨੂੰ ਸਟ੍ਰੀਮ ਕਰਦਾ ਹੈ: ਸਟੇਜ ਸ਼ੁਰੂ/ਪੂਰਤੀ, ਗੇਟ, ਅਲਰਟ, ਅਤੇ ਪ੍ਰੀਵਿਊ ਤੁਰੰਤ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ।
• ਟਿਕਾਊ ਲੌਗ & ਰੀਪਲੇਅ — ਇਵੈਂਟਸ ਪ੍ਰਤੀ ਵਰਕਸਪੇਸ ਬਰਕਰਾਰ ਰਹਿੰਦੇ ਹਨ ਅਤੇ ਵਿਸ਼ੇ ਦੇ ਪੈਟਰਨ ਅਤੇ ਕਲਾਸ ਦੁਆਰਾ ਆਡਿਟ ਅਤੇ ਡੀਬੱਗਿੰਗ ਲਈ ਰੀਪਲੇਅ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ।

17.3.1 ਏਜੰਟਾਂ ਲਈ ਇਵੈਂਟ ਕਤਾਰਬੱਧ ਕਰਨਾ

ਏਜੰਟ ਜੋ ਘਟਨਾਵਾਂ 'ਤੇ ਪ੍ਰਤੀਕਿਰਿਆ ਕਰਦੇ ਹਨ, ਉਹ ਇੱਕ ਟਿਕਾਊ ਨਾਮੀ ਕਤਾਰ ਘੋਸ਼ਿਤ ਕਰ ਸਕਦੇ ਹਨ ਤਾਂ ਜੋ ਮੇਲ ਖਾਂਦੀਆਂ ਘਟਨਾਵਾਂ ਕਦੇ ਨਾ ਗੁੰਮ ਹੋਣ ਜਦੋਂ ਏਜੰਟ ਵਿਅਸਤ ਹੋਵੇ ਜਾਂ ਕੋਈ ਰਨ ਸੁਣਨ ਤੋਂ ਪਹਿਲਾਂ। ਇੱਕ ਟ੍ਰਿਗਰ ਸਬਸਕ੍ਰਿਪਸ਼ਨ 'ਤੇ, ਸੈੱਟ ਕਰੋ queue: <name> — ਇੰਜਣ ਉਸ ਵਿਸ਼ੇ ਨੂੰ ਵਰਕਸਪੇਸ ਈਵੈਂਟ ਬੱਸ 'ਤੇ ਇੱਕ FIFO ਕਤਾਰ ਨਾਲ ਬੰਨ੍ਹਦਾ ਹੈ (.deepcerebra/workflows/events/queues/ ਦੇ ਅਧੀਨ ਸਥਾਈ ਕੀਤਾ ਗਿਆ)। ਉਸ ਬਿੰਦੂ ਤੋਂ ਪ੍ਰਕਾਸ਼ਿਤ ਹਰ ਮੇਲ ਖਾਂਦੀ ਘਟਨਾ ਕਤਾਰ ਵਿੱਚ ਕੈਪਚਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ; ਜਦੋਂ ਪੜਾਅ ਚੱਲਣਯੋਗ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇੰਜਣ ਘਟਨਾਵਾਂ ਨੂੰ ਸਭ ਤੋਂ ਪੁਰਾਣੇ-ਪਹਿਲਾਂ ਕ੍ਰਮ ਵਿੱਚ ਪੌਪ ਕਰਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਇੱਕ-ਇੱਕ ਕਰਕੇ ਖਪਤ ਕਰਦਾ ਹੈ।

• ਕੁਝ ਵੀ ਨਹੀਂ ਗੁਆਚਿਆ — ਇਵੈਂਟ ਜੋ ਵਰਕਫਲੋ ਬੰਦ ਹੋਣ 'ਤੇ ਪ੍ਰਕਾਸ਼ਿਤ ਹੁੰਦੇ ਹਨ, ਜਦੋਂ ਕੋਈ ਹੋਰ ਸਟੇਜ ਚੱਲ ਰਹੀ ਹੁੰਦੀ ਹੈ, ਜਾਂ ਜਦੋਂ ਰਨ ਅਜੇ ਵੀ ਨਿਰਭਰਤਾਵਾਂ 'ਤੇ ਉਡੀਕ ਕਰ ਰਹੀ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਛੱਡਣ ਦੀ ਬਜਾਏ ਕਤਾਰਬੱਧ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
• ਪ੍ਰਤੀ-ਸਬਸਕ੍ਰਿਪਸ਼ਨ count — ਸਬਸਕ੍ਰਿਪਸ਼ਨ ਸੰਤੁਸ਼ਟ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ N ਕਤਾਰਬੱਧ (ਜਾਂ ਡਿਲੀਵਰ ਕੀਤੇ) ਇਵੈਂਟਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ (ਉਦੋਂ ਲਾਭਦਾਇਕ ਜਦੋਂ ਕਈ ਕਰਮਚਾਰੀਆਂ ਨੂੰ ਰਿਪੋਰਟ ਕਰਨੀ ਪੈਂਦੀ ਹੈ)।
• ਸਟੂਡੀਓ — ਇੰਸਪੈਕਟਰ ਦੇ ਇਵੈਂਟਸ ਪੈਨਲ ਵਿੱਚ, ਇੱਕ ਟ੍ਰਿਗਰ ਸਬਸਕ੍ਰਿਪਸ਼ਨ 'ਤੇ ਕਤਾਰ ਫੀਲਡ ਸੈੱਟ ਕਰੋ; ਬਾਈਡਿੰਗ ਨੂੰ ਆਪਣੇ ਆਪ ਬਣਾਉਣ ਲਈ ਟ੍ਰਿਗਰਾਂ ਨੂੰ ਆਰਮ ਕਰੋ ਜਾਂ ਇੱਕ ਰਨ ਸ਼ੁਰੂ ਕਰੋ।
• API ਅਤੇ ਟੂਲ — 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

17.3.2 ਸੇਮਾਫੋਰ ਆਰਕੈਸਟ੍ਰੇਸ਼ਨ (ਸਾਂਝੇ-ਸਰੋਤ ਸੁਰੱਖਿਆ)

ਇੱਕ ਸੈਮਾਫੋਰ ਸੀਮਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕਿੰਨੇ ਕਾਰਜ ਇੱਕੋ ਸਮੇਂ ਇੱਕ ਸਾਂਝੇ (ਸੁਰੱਖਿਅਤ) ਸਰੋਤ 'ਤੇ ਕੰਮ ਕਰ ਸਕਦੇ ਹਨ: ਇੱਕ ਡਾਟਾਬੇਸ ਜਿਸ ਵਿੱਚ ਲਿਖਿਆ ਜਾ ਰਿਹਾ ਹੈ, ਇੱਕ ਗਲੋਬਲ ਵੇਰੀਏਬਲ ਸਟੋਰ, ਇੱਕ ਫਾਈਲ, ਜਾਂ ਇੱਕ ਰੇਟ-ਸੀਮਤ ਬਾਹਰੀ ਏਜੰਟ। ਇਸਨੂੰ ਕਿਸੇ ਵੀ ਪੜਾਅ ਨਾਲ ਜੋੜੋ semaphore: — ਪੜਾਅ ਦਾ ਕੰਮ ਚੱਲਣ ਤੋਂ ਪਹਿਲਾਂ, ਇੰਜਣ ਨਾਮਿਤ ਵਰਕਸਪੇਸ ਸੈਮਾਫੋਰ ਦਾ ਇੱਕ ਪਰਮਿਟ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ; ਪਰਮਿਟ ਹਮੇਸ਼ਾ ਜਾਰੀ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਬਾਅਦ ਵਿੱਚ, ਭਾਵੇਂ ਪੜਾਅ ਅਸਫਲ ਹੋ ਜਾਵੇ। permits: 1 ਇਸਨੂੰ ਇੱਕ ਮਿਊਟੈਕਸ ਬਣਾਉਂਦਾ ਹੈ: ਇੱਕ ਸਮੇਂ ਸਿਰਫ਼ ਇੱਕ ਕਾਰਜ (ਵਰਕਸਪੇਸ ਵਿੱਚ ਸਾਰੀਆਂ ਸਮਾਂਤਰ ਰਨਾਂ ਵਿੱਚ) ਨਾਜ਼ੁਕ ਕਦਮ ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ; ਹਰ ਦੂਜਾ ਕਾਰਜ ਉਦੋਂ ਤੱਕ ਉਡੀਕ ਕਰਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਧਾਰਕ ਖਤਮ ਨਹੀਂ ਕਰਦਾ।

• ਕ੍ਰਾਸ-ਰਨ ਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ — semaphores ਵਰਕਸਪੇਸ-ਸਕੋਪਡ ਅਤੇ ਸਥਾਈ ਹੁੰਦੇ ਹਨ, ਇਸਲਈ ਦੋ ਸਮਕਾਲੀ ਵਰਕਫਲੋ ਰਨ ਇੱਕੋ ਸੁਰੱਖਿਅਤ ਸਰੋਤ ਨੂੰ ਖਰਾਬ ਨਹੀਂ ਕਰ ਸਕਦੇ।
• ਉਡੀਕ ਕਰਨਾ, ਲਟਕਣਾ ਨਹੀਂ — ਕਾਰਜ ਇੱਕ ਪਰਮਿਟ ਲਈ 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          # ਮਿਊਟੈਕਸ — ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਇੱਕ ਲੇਖਕ
  timeout_s: 300      # ਜੇਕਰ 5 ਮਿੰਟ ਬਾਅਦ ਵੀ ਉਡੀਕ ਕਰ ਰਿਹਾ ਹੈ ਤਾਂ ਅਸਫਲ ਹੋਵੋ
  ttl_s: 900          # 15 ਮਿੰਟਾਂ ਬਾਅਦ ਕ੍ਰੈਸ਼ ਹੋਏ ਹੋਲਡਰਾਂ ਨੂੰ ਆਪਣੇ ਆਪ ਜਾਰੀ ਕਰੋ

17.3.3 ਰੈਂਡੇਜ਼ਵਸ ਆਰਕੈਸਟ੍ਰੇਸ਼ਨ (ਸਾਰੀਆਂ ਸ਼ਰਤਾਂ ਦੀ ਉਡੀਕ ਕਰੋ)

ਰੈਂਡੇਜ਼ਵਸ ਉਦੋਂ ਤੱਕ ਉਡੀਕ ਕਰਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਅਗਲਾ ਕਦਮ ਅੱਗੇ ਵਧਣ ਤੋਂ ਪਹਿਲਾਂ ਕਈ ਇਵੈਂਟ ਸ਼ਰਤਾਂ ਪੂਰੀਆਂ ਨਹੀਂ ਹੋ ਜਾਂਦੀਆਂ — "ਪਹਿਲਾ ਇਵੈਂਟ ਜਿੱਤਦਾ ਹੈ" ਦੇ ਉਲਟ। ਸਟੇਜ ਦੇ events: ਬਲਾਕ 'ਤੇ join: all ਸੈੱਟ ਕਰੋ: ਹਰੇਕ ਟ੍ਰਿਗਰ ਸਬਸਕ੍ਰਿਪਸ਼ਨ ਸੰਤੁਸ਼ਟ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ ਤੋਂ ਪਹਿਲਾਂ ਸਟੇਜ ਚੱਲਦੀ ਹੈ। ਪ੍ਰਤੀ-ਸਬਸਕ੍ਰਿਪਸ਼ਨ count: N ਨਾਲ ਜੋੜੋ ਜਦੋਂ ਕਈ ਏਜੰਟ (ਜਾਂ ਇੱਕ ਏਜੰਟ ਤੋਂ ਕਈ ਰਿਪੋਰਟਾਂ) ਨੂੰ ਸਾਰਿਆਂ ਨੂੰ ਚੈੱਕ ਇਨ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ — ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਰੀਲੀਜ਼ ਸਟੇਜ ਚੱਲਣ ਤੋਂ ਪਹਿਲਾਂ ਡਿਜ਼ਾਈਨ ਸਾਈਨ-ਆਫ, ਟੈਸਟ ਪੂਰਤੀ, ਅਤੇ ਸੁਰੱਖਿਆ ਪ੍ਰਵਾਨਗੀ।

• join: any (ਡਿਫੌਲਟ) — ਸਟੇਜ ਉਦੋਂ ਚੱਲਦੀ ਹੈ ਜਦੋਂ ਪਹਿਲੀ ਟ੍ਰਿਗਰ ਸਬਸਕ੍ਰਿਪਸ਼ਨ ਸੰਤੁਸ਼ਟ ਹੁੰਦੀ ਹੈ।
• join: all — ਰੈਂਡੇਜ਼ਵਸ: ਹਰੇਕ ਟ੍ਰਿਗਰ ਸਬਸਕ੍ਰਿਪਸ਼ਨ (ਹਰੇਕ ਆਪਣੇ ਵਿਸ਼ੇ, ਕਲਾਸ ਫਿਲਟਰ, ਅਤੇ ਵਿਕਲਪਿਕ count ਨਾਲ) ਸੰਤੁਸ਼ਟ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ; ਸਿਰਫ ਤਾਂ ਹੀ ਸਟੇਜ ਚੱਲਣਯੋਗ ਬਣਦੀ ਹੈ।
• ਪੇਲੋਡ — ਸਾਰੇ ਖਪਤ ਕੀਤੇ ਇਵੈਂਟ ਸਟੇਜ 'ਤੇ trigger_events ਵਜੋਂ ਰਿਕਾਰਡ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਅਤੇ ਟੈਂਪਲੇਟਾਂ ਨੂੰ inputs.events (ਪੇਲੋਡ ਵਾਲੇ ਇਵੈਂਟ ਆਬਜੈਕਟਾਂ ਦੀ ਇੱਕ ਸੂਚੀ) ਵਜੋਂ ਪ੍ਰਗਟ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।
• ਸਟੂਡੀਓ — ਜਦੋਂ ਇੱਕ ਸਟੇਜ ਵਿੱਚ ਦੋ ਜਾਂ ਵੱਧ ਟ੍ਰਿਗਰ ਸਬਸਕ੍ਰਿਪਸ਼ਨ ਹੁੰਦੀਆਂ ਹਨ, ਤਾਂ ਇੰਸਪੈਕਟਰ ਇੱਕ ਜੋਇਨ ਸਿਲੈਕਟਰ ਦਿਖਾਉਂਦਾ ਹੈ: ਕੋਈ ਵੀ — ਪਹਿਲਾ ਇਵੈਂਟ ਜਿੱਤਦਾ ਹੈ ਜਾਂ ਸਾਰੇ — ਰੈਂਡੇਜ਼ਵਸ (ਸਾਰਿਆਂ ਦੀ ਉਡੀਕ ਕਰੋ); ਕੈਨਵਸ ਰੈਂਡੇਜ਼ਵਸ ਸਟੇਜਾਂ 'ਤੇ ਇੱਕ ਮਰਜ ਬੈਜ ਦਿਖਾਉਂਦਾ ਹੈ।

events:
  join: all                    # ਰੈਂਡੇਜ਼ਵਸ — ਹੇਠਾਂ ਦਿੱਤੀ ਹਰੇਕ ਸਬਸਕ੍ਰਿਪਸ਼ਨ ਦੀ ਉਡੀਕ ਕਰੋ
  subscribe:
    - topic: design.approved
      mode: trigger
    - topic: tests.passed
      mode: trigger
    - topic: security.cleared
      mode: trigger
      count: 1

17.4 ਏਜੰਟ ਟੂਲ ਲਾਇਬ੍ਰੇਰੀ

ਸਟੇਜ ਉਸੇ ਰਜਿਸਟਰੀ ਤੋਂ ਟੂਲ ਚੁਣਦੇ ਹਨ ਜੋ ਚੈਟ ਏਜੰਟ ਵਰਤਦਾ ਹੈ:

• ਕੋਰ — ਫਾਈਲਾਂ, git, ਸ਼ੈੱਲ, ਕੋਡ ਐਗਜ਼ੀਕਿਊਸ਼ਨ, ਕੋਡ ਖੋਜ, ਬ੍ਰਾਊਜ਼ਰ ਆਟੋਮੇਸ਼ਨ, ਵੈੱਬ ਖੋਜ, ਵਿਜ਼ਨ/ਮੀਡੀਆ, ਚਿੱਤਰ ਜਨਰੇਸ਼ਨ।
• ਡਾਟਾਬੇਸ — SQLite, PostgreSQL, MySQL, MongoDB, ਅਤੇ Redis ਕਵੇਰੀਆਂ ਨਾਲ create_database, apply_migrations, ਅਤੇ dump_schema ਮਲਕੀਅਤ ਵਾਲੀਆਂ ਡਾਟਾ ਲੇਅਰਾਂ ਲਈ।
• ਸੰਚਾਰ — ਫ਼ੋਨ ਕਾਲਾਂ ਅਤੇ SMS (Twilio) ਅਤੇ ਈਮੇਲ (SendGrid), ਇੱਕ ਸਿਮੂਲੇਸ਼ਨ ਮੋਡ ਦੇ ਨਾਲ ਜੋ ਪ੍ਰਮਾਣ ਪੱਤਰਾਂ ਦੀ ਅਣਹੋਂਦ ਵਿੱਚ ਇੱਕ ਆਉਟਬਾਕਸ ਵਿੱਚ ਰਿਕਾਰਡ ਕਰਦਾ ਹੈ — ਡੈਮੋ ਕਦੇ ਵੀ ਗਲਤੀ ਨਾਲ ਅਸਲ ਸੁਨੇਹੇ ਨਹੀਂ ਭੇਜਦੇ।
• DevOps — docker_build / docker_push, ਕੰਪੋਜ਼ ਅੱਪ/ਡਾਊਨ, SSH ਅਤੇ ਕਲਾਉਡ-CLI ਤੈਨਾਤੀਆਂ (Fly, Render, Railway, Vercel), ਵੀ ਸਿਮੂਲੇਸ਼ਨ-ਸੁਰੱਖਿਅਤ।
• ਪੁਸ਼ਟੀਕਰਨ — ਸਟੈਕ ਖੋਜ, ਪਾਰਸ ਕੀਤੀਆਂ ਪਾਸ ਦਰਾਂ ਨਾਲ ਟੈਸਟ-ਸੂਟ ਐਗਜ਼ੀਕਿਊਸ਼ਨ, ਨਿਰਭਰਤਾ ਆਡਿਟ, ਅਤੇ ਗੁਪਤ ਸਕੈਨਿੰਗ।
• ਸਾਇੰਸਕੰਪਿਊਟ ਇੰਜਣ — ਗਣਿਤ, ਸਿਗਨਲ ਪ੍ਰੋਸੈਸਿੰਗ, ਕੰਟਰੋਲ, ਅੰਕੜੇ, ਅਤੇ ਹੋਰ ਬਹੁਤ ਸਾਰੇ ਖੇਤਰਾਂ ਵਿੱਚ ਸੈਂਕੜੇ ਵਿਗਿਆਨਕ ਅਤੇ ਇੰਜੀਨੀਅਰਿੰਗ ਵਿਧੀਆਂ (ਨਾਮ Class.method)।
• ਮਾਹਿਰ ਏਜੰਸੀ & MCP — ਆਧਾਰਿਤ ਡੋਮੇਨ ਖੋਜ ਅਤੇ ਕੋਈ ਵੀ ਬਾਹਰੀ MCP ਸਰਵਰ ਜਿਨ੍ਹਾਂ ਨੂੰ ਤੁਸੀਂ ਕਨੈਕਟ ਕਰਦੇ ਹੋ।

17.5 ਚਲਾਉਣਾ, ਗੇਟ, ਅਤੇ ਆਉਟਪੁੱਟ

• ਪ੍ਰਮਾਣਿਤ ਕਰੋ ਗ੍ਰਾਫ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ (ਵਿਲੱਖਣ ਆਈਡੀ, ਅਸਾਈਕਲਿਕ ਨਿਰਭਰਤਾਵਾਂ, ਕਿਸਮ ਪੈਰਾਮੀਟਰ) ਚਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ।
• ਮਨੁੱਖੀ ਗੇਟ ਸਟੇਜ ਦੇ ਆਪਣੇ ਡਰਾਫਟ ਤਿਆਰ ਕਰਨ ਤੋਂ ਬਾਅਦ ਰਨ ਨੂੰ ਰੋਕਦੇ ਹਨ, ਤਾਂ ਜੋ ਤੁਸੀਂ ਅਸਲ ਕੰਮ ਨੂੰ ਪ੍ਰਵਾਨ ਕਰੋ; ਇਵੈਂਟ ਗੇਟ ਕਿਸੇ ਹੋਰ ਸਿਸਟਮ ਨੂੰ ਆਪਣੇ ਆਪ ਪ੍ਰਵਾਨ ਕਰਨ ਦਿੰਦੇ ਹਨ।
• ਬਜਟ ਪ੍ਰਤੀ ਰਨ ਅਤੇ ਪ੍ਰਤੀ ਸਟੇਜ ਖਰਚ ਨੂੰ ਸੀਮਤ ਕਰਦੇ ਹਨ।
• ਆਉਟਪੁੱਟਸ ਨੂੰ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਸੇਵ ਕਰੋ ਇੱਕ ਰਨ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੀ ਹਰ ਕਲਾਕ੍ਰਿਤੀ ਨੂੰ ਤੁਹਾਡੇ ਖੁੱਲ੍ਹੇ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਕਾਪੀ ਕਰਦਾ ਹੈ।
• ਐਪ ਨਿਰਯਾਤ ਕਰੋ ਵਰਕਫਲੋ ਨੂੰ ਇੱਕ ਸਟੈਂਡਅਲੋਨ FastAPI ਸੇਵਾ ਵਿੱਚ ਬਦਲਦਾ ਹੈ; ਜਨਤਕ /v1 API CI ਅਤੇ ਏਕੀਕਰਣਾਂ ਲਈ ਰਨ, ਇਵੈਂਟਸ, ਟ੍ਰਿਗਰ, ਟੈਂਪਲੇਟ, ਅਤੇ ਜਨਰੇਸ਼ਨ ਨੂੰ ਪ੍ਰਗਟ ਕਰਦਾ ਹੈ।

18 ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਵਾਲੀ ਟੈਬ ਪੂਰਤੀ

ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਵਾਲੀ ਟੈਬ ਪੂਰਤੀ ਇਨਲਾਈਨ, ਫਿਲ-ਇਨ-ਦ-ਮਿਡਲ ਕੋਡ ਸੁਝਾਅ ਪੇਸ਼ ਕਰਦੀ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਐਡੀਟਰ ਵਿੱਚ ਟਾਈਪ ਕਰਦੇ ਹੋ — Tab ਨਾਲ ਇੱਕ ਸੁਝਾਅ ਸਵੀਕਾਰ ਕਰੋ। ਇਹ ਇੰਜਣ ਅਤੇ ਵੈੱਬ ਐਡੀਟਰ ਦੋਵਾਂ 'ਤੇ ਆਪਟ-ਇਨ ਹੈ।

ਇਸਨੂੰ ਸਮਰੱਥ ਬਣਾਓ

• ਇੰਜਣ — ਵਾਤਾਵਰਣ ਫਲੈਗ DCC_TAB_COMPLETE=1 ਸੈੱਟ ਕਰੋ। ਐਡੀਟਰ ਇੰਜਣ ਦੇ POST /api/complete ਐਂਡਪੁਆਇੰਟ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ, ਜੋ ਸਿਰਫ ਕਰਸਰ 'ਤੇ ਪਾਉਣ ਲਈ ਟੈਕਸਟ ਵਾਪਸ ਕਰਦਾ ਹੈ।
• ਵੈੱਬ ਐਡੀਟਰ — ਬਿਲਡ ਸਮੇਂ VITE_TAB_COMPLETE=1 ਨਾਲ, ਜਾਂ ਰਨਟਾਈਮ 'ਤੇ localStorage.setItem('dcc.tabComplete', '1') (ਫਿਰ ਰੀਲੋਡ ਕਰੋ) ਨਾਲ ਸਮਰੱਥ ਬਣਾਓ।

ਇਹ ਕਿਵੇਂ ਵਿਵਹਾਰ ਕਰਦਾ ਹੈ

• ਸੁਝਾਅ ਭੂਤ ਟੈਕਸਟ ਵਜੋਂ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ; ਸਵੀਕਾਰ ਕਰਨ ਲਈ Tab ਦਬਾਓ, ਜਾਂ ਖਾਰਜ ਕਰਨ ਲਈ ਟਾਈਪ ਕਰਦੇ ਰਹੋ।
• ਬੇਨਤੀਆਂ ਨੂੰ ਡੀਬਾਊਂਸ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਰੱਦ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਇਸ ਲਈ ਟਾਈਪਿੰਗ ਕਦੇ ਵੀ ਬਲੌਕ ਨਹੀਂ ਹੁੰਦੀ।
• ਜਦੋਂ ਫਲੈਗ ਬੰਦ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਵਿਸ਼ੇਸ਼ਤਾ ਪੂਰੀ ਤਰ੍ਹਾਂ ਅਯੋਗ ਹੋ ਜਾਂਦੀ ਹੈ ਅਤੇ ਕੋਈ ਪੂਰਤੀ ਬੇਨਤੀਆਂ ਨਹੀਂ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ।

19 ਵਰਤੋਂ, ਕ੍ਰੈਡਿਟ ਅਤੇ ਬਿਲਿੰਗ

ਆਪਣੀ ਯੋਜਨਾ ਅਤੇ ਵਰਤੋਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ ਸਾਈਡਬਾਰ ਤੋਂ ਬਿਲਿੰਗ ਖੋਲ੍ਹੋ। AI ਵਰਤੋਂ ਅੰਡਰਲਾਈੰਗ ਮਾਡਲਾਂ ਦੁਆਰਾ ਖਪਤ ਕੀਤੇ ਟੋਕਨਾਂ ਦੇ ਅਧਾਰ 'ਤੇ U.S.-ਡਾਲਰ ਕ੍ਰੈਡਿਟ ਵਿੱਚ ਮੀਟਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

• ਸਾਈਕਲ ਖਰਚ & ਪ੍ਰੀਪੇਡ ਕ੍ਰੈਡਿਟ — ਇਸ ਸਾਈਕਲ ਵਿੱਚ ਵਰਤੋਂ ਨੂੰ ਟਰੈਕ ਕਰੋ ਅਤੇ ਕਿਸੇ ਵੀ ਪ੍ਰੀਪੇਡ ਬਕਾਏ ਨੂੰ।
• ਵਾਧੂ ਕ੍ਰੈਡਿਟ ਸ਼ਾਮਲ ਕਰੋ — ਸ਼ਾਮਲ ਭੱਤੇ ਦੇ ਖਰਚ ਹੋਣ ਤੋਂ ਬਾਅਦ AI ਦੀ ਵਰਤੋਂ ਜਾਰੀ ਰੱਖਣ ਲਈ ਇੱਕ ਵਾਧੂ ਰਕਮ (USD) ਨੂੰ ਅਧਿਕਾਰਤ ਕਰੋ; ਜੇਕਰ ਤੁਹਾਡਾ ਬਜਟ ਖਤਮ ਹੋ ਜਾਂਦਾ ਹੈ ਤਾਂ ਤੁਹਾਨੂੰ ਕ੍ਰੈਡਿਟ ਜੋੜਨ ਲਈ ਪ੍ਰੇਰਿਤ ਕਰਨ ਵਾਲਾ ਇੱਕ ਬੈਨਰ ਦਿਖਾਈ ਦੇਵੇਗਾ।
• ਅੱਪਗ੍ਰੇਡ / ਯੋਜਨਾ ਬਦਲੋ — ਕਿਸੇ ਵੀ ਸਮੇਂ ਟੀਅਰ ਬਦਲੋ।
• ਭੁਗਤਾਨ ਵਿਧੀ — ਫਾਈਲ 'ਤੇ ਕਾਰਡ ਸ਼ਾਮਲ ਕਰੋ ਜਾਂ ਅੱਪਡੇਟ ਕਰੋ (Stripe ਦੁਆਰਾ ਪ੍ਰੋਸੈਸ ਕੀਤਾ ਗਿਆ)।
• ਰੱਦ ਕਰੋ — ਮਿਆਦ ਦੇ ਅੰਤ 'ਤੇ ਰੱਦ ਕਰੋ (ਮਿਆਦ ਖਤਮ ਹੋਣ ਤੱਕ ਪਹੁੰਚ ਰੱਖੋ) ਜਾਂ ਹੁਣੇ ਰੱਦ ਕਰੋ (ਵਾਪਸੀਯੋਗ ਬਕਾਇਆ ਵਾਪਸ ਕਰੋ) ਚੁਣੋ। ਰੱਦ ਕਰਨ ਅਤੇ ਰਿਫੰਡ ਨੀਤੀ ਦੇਖੋ।

20 ਆਪਣੀ ਗੇਟਵੇ API ਕੁੰਜੀ ਪ੍ਰਾਪਤ ਕਰਨਾ

ਇੱਕ ਗੇਟਵੇ API ਕੁੰਜੀ (ਇੱਕ ਨਿੱਜੀ ਐਕਸੈਸ ਟੋਕਨ) ਤੁਹਾਨੂੰ DeepCerebra ਜਨਤਕ API ਅਤੇ CLI ਨੂੰ ਪ੍ਰੋਗਰਾਮੈਟਿਕ ਤੌਰ 'ਤੇ ਵਰਤਣ ਦਿੰਦੀ ਹੈ।

1. ਸਾਈਨ ਇਨ ਕਰੋ ਅਤੇ ਸਾਈਡਬਾਰ ਤੋਂ API ਕੁੰਜੀਆਂ ਖੋਲ੍ਹੋ।
2. DeepCerebra API ਕੁੰਜੀਆਂ 'ਤੇ ਸਕ੍ਰੋਲ ਕਰੋ।
3. ਇੱਕ ਲੇਬਲ ਦਰਜ ਕਰੋ (ਉਦਾਹਰਨ ਲਈ "CI ਪਾਈਪਲਾਈਨ" ਜਾਂ "ਲੈਪਟਾਪ CLI")।
4. ਸਕੋਪ ਚੁਣੋ — read, chat, code, agent — ਅਤੇ ਦਿਨਾਂ ਵਿੱਚ ਇੱਕ ਵਿਕਲਪਿਕ ਮਿਆਦ ਪੁੱਗਣ ਦੀ ਮਿਤੀ (ਖਾਲੀ = ਕਦੇ ਨਹੀਂ)।
5. ਕਲਿੱਕ ਕਰੋ ਬਣਾਓ। ਪੂਰੀ ਕੁੰਜੀ ਸਿਰਫ਼ ਇੱਕ ਵਾਰ ਦਿਖਾਈ ਜਾਂਦੀ ਹੈ — ਕਲਿੱਕ ਕਰੋ ਕਾਪੀ ਕਰੋ ਅਤੇ ਇਸਨੂੰ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਸਟੋਰ ਕਰੋ।

ਇਸਨੂੰ 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/...

ਤੁਸੀਂ ਕਿਸੇ ਵੀ ਸਮੇਂ ਇੱਕ ਕੁੰਜੀ ਨੂੰ ਨਾਮ ਬਦਲ ਜਾਂ ਮਿਟਾ (ਰੱਦ) ਸਕਦੇ ਹੋ; ਹਰੇਕ ਕੁੰਜੀ ਇਸਦਾ ਪ੍ਰੀਫਿਕਸ, ਸਕੋਪ, ਬਣਾਇਆ/ਮਿਆਦ ਪੁੱਗਣ ਦੀ ਮਿਤੀ, ਅਤੇ ਆਖਰੀ ਵਾਰ ਵਰਤੀ ਗਈ ਮਿਤੀ ਦਿਖਾਉਂਦੀ ਹੈ।

21 ਸੁਰੱਖਿਆ ਅਤੇ ਗੋਪਨੀਯਤਾ

• ਗੁਪਤ ਇਨ-ਬ੍ਰਾਊਜ਼ਰ ਸਟੋਰੇਜ — ਤੁਹਾਡੀਆਂ ਪ੍ਰੋਜੈਕਟ ਫਾਈਲਾਂ ਬ੍ਰਾਊਜ਼ਰ ਦੇ ਏਨਕ੍ਰਿਪਟਡ ਵਰਕਸਪੇਸ ਵਿੱਚ ਰਹਿੰਦੀਆਂ ਹਨ; ਪ੍ਰਤੀ ਬੇਨਤੀ ਸਿਰਫ ਘੱਟੋ-ਘੱਟ ਸੰਦਰਭ ਦੀ ਲੋੜ ਸਰਵਰ ਨੂੰ ਭੇਜੀ ਜਾਂਦੀ ਹੈ।
• ਜ਼ੀਰੋ ਡਾਟਾ ਰੀਟੈਂਸ਼ਨ (ZDR) — ਮਾਡਲਾਂ ਨੂੰ ਭੇਜੇ ਗਏ ਪ੍ਰੋਂਪਟ ਅਤੇ ਕੋਡ ਬੇਨਤੀ ਤੋਂ ਬਾਅਦ ਬਰਕਰਾਰ ਨਹੀਂ ਰੱਖੇ ਜਾਂਦੇ ਅਤੇ ਕਦੇ ਵੀ ਫਾਊਂਡੇਸ਼ਨ ਮਾਡਲਾਂ ਨੂੰ ਸਿਖਲਾਈ ਦੇਣ ਲਈ ਵਰਤੇ ਨਹੀਂ ਜਾਂਦੇ।
• ਕੁੰਜੀਆਂ ਸਰਵਰ-ਸਾਈਡ ਰਹਿੰਦੀਆਂ ਹਨ — BYOK ਅਤੇ SCM ਟੋਕਨ ਆਰਾਮ 'ਤੇ ਏਨਕ੍ਰਿਪਟ ਕੀਤੇ ਜਾਂਦੇ ਹਨ; ਸਿਰਫ ਮਾਸਕਡ ਪ੍ਰੀਵਿਊ ਦਿਖਾਏ ਜਾਂਦੇ ਹਨ।
• ਏਨਕ੍ਰਿਪਸ਼ਨ — ਆਵਾਜਾਈ ਵਿੱਚ TLS; ਖਾਤਾ ਡਾਟਾ ਆਰਾਮ 'ਤੇ ਏਨਕ੍ਰਿਪਟ ਕੀਤਾ ਗਿਆ; ਪਾਸਵਰਡ ਅਟੱਲ ਤੌਰ 'ਤੇ ਹੈਸ਼ ਕੀਤੇ ਗਏ।
• ਤੁਹਾਡਾ ਕੋਡ ਤੁਹਾਡਾ ਹੈ — ਤੁਸੀਂ ਆਪਣੀ ਸਮੱਗਰੀ ਅਤੇ ਤਿਆਰ ਕੀਤੀ ਆਉਟਪੁੱਟ ਦੇ ਮਾਲਕ ਹੋ। ਗੋਪਨੀਯਤਾ ਬਿਆਨ ਦੇਖੋ।

22 ਸਮੱਸਿਆ ਨਿਵਾਰਨ

"ਫੋਲਡਰ ਲੋਡ ਕਰਨ ਲਈ ਇੱਕ Chromium ਬ੍ਰਾਊਜ਼ਰ ਦੀ ਲੋੜ ਹੈ"

Chrome, Edge, ਜਾਂ Brave 'ਤੇ ਸਵਿੱਚ ਕਰੋ, ਜਾਂ ਇਸਦੀ ਬਜਾਏ Git ਤੋਂ ਖੋਲ੍ਹੋ ਦੀ ਵਰਤੋਂ ਕਰੋ।

ਏਜੰਟ ਉਸੇ ਗਲਤੀ 'ਤੇ ਲੂਪ ਕਰਦਾ ਹੈ

ਰੋਕੋ 'ਤੇ ਕਲਿੱਕ ਕਰੋ, ਫਿਰ ਇੱਕ ਠੋਸ ਸੰਕੇਤ ਜਾਂ ਰੁਕਾਵਟ ਨਾਲ ਮੁੜ-ਵਾਕ ਕਰੋ।

ਮਾਡਲ ਜਾਂ ਬੇਨਤੀ ਗਲਤੀਆਂ / "ਬਜਟ ਖਤਮ ਹੋ ਗਿਆ"

• ਆਪਣਾ ਕਨੈਕਸ਼ਨ ਚੈੱਕ ਕਰੋ ਅਤੇ ਇਹ ਕਿ ਕੋਈ ਵੀ BYOK key ਵੈਧ ਹੈ।
• ਆਟੋ 'ਤੇ ਸਵਿੱਚ ਕਰੋ ਤਾਂ ਜੋ DeepCerebra ਇੱਕ ਉਪਲਬਧ ਮਾਡਲ 'ਤੇ ਰੂਟ ਕਰੇ।
• ਜੇਕਰ ਤੁਹਾਡਾ ਵਰਤੋਂ ਬਜਟ ਖਤਮ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਬਿਲਿੰਗ ਖੋਲ੍ਹੋ ਅਤੇ ਵਾਧੂ ਕ੍ਰੈਡਿਟ ਸ਼ਾਮਲ ਕਰੋ ਜਾਂ ਆਪਣੀ ਯੋਜਨਾ ਨੂੰ ਅੱਪਗ੍ਰੇਡ ਕਰੋ।

ਸਥਾਨਕ ਮਾਡਲ ਦਿਖਾਈ ਨਹੀਂ ਦਿੰਦੇ

• ਪੁਸ਼ਟੀ ਕਰੋ ਕਿ dcc-bridge ਕਨੈਕਟਰ ਚੱਲ ਰਿਹਾ ਹੈ ਅਤੇ ਡਿਵਾਈਸ ਔਨਲਾਈਨ ਦਿਖਾਉਂਦਾ ਹੈ।
• ਯਕੀਨੀ ਬਣਾਓ ਕਿ Ollama ਚੱਲ ਰਿਹਾ ਹੈ, ਜਾਂ LM Studio ਦਾ ਸਥਾਨਕ ਸਰਵਰ ਸਮਰੱਥ ਹੈ (ਡਿਫੌਲਟ ਪੋਰਟ 1234) ਇੱਕ ਲੋਡ ਕੀਤੇ ਮਾਡਲ ਨਾਲ।

ਕਨੈਕਟਰ: "ਸਰਵਰ ਨੇ WebSocket ਕਨੈਕਸ਼ਨ ਨੂੰ ਰੱਦ ਕਰ ਦਿੱਤਾ: HTTP 401"

• --gateway ਵਜੋਂ ਉਹੀ ਡੋਮੇਨ ਵਰਤੋ ਜੋ ਤੁਸੀਂ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਵਰਤਦੇ ਹੋ (wss://deepcerebra.ai ਜਾਂ wss://deepcerebra.io) — ਦੋ ਸਾਈਟਾਂ ਵੱਖਰੇ ਤੈਨਾਤੀਆਂ ਹਨ, ਅਤੇ ਇੱਕ ਤੋਂ ਇੱਕ ਟੋਕਨ ਕਦੇ ਵੀ ਦੂਜੀ 'ਤੇ ਕੰਮ ਨਹੀਂ ਕਰਦਾ।
• ਸਥਾਨਕ ਮਸ਼ੀਨ ਪੇਜ 'ਤੇ ਪੇਅਰਿੰਗ ਕਾਰਡ ਤੋਂ ਸਹੀ ਕਮਾਂਡ ਦੀ ਨਕਲ ਕਰੋ।

ਮੇਰੀਆਂ ਤਬਦੀਲੀਆਂ ਲਾਗੂ ਨਹੀਂ ਹੋਈਆਂ

• ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਸੀਂ ਪ੍ਰਸਤਾਵਿਤ ਤਬਦੀਲੀਆਂ ਵਿੱਚ ਲਾਗੂ ਕਰੋ 'ਤੇ ਕਲਿੱਕ ਕੀਤਾ ਹੈ (ਸਿਰਫ ਡਿਫ ਦਾ ਪ੍ਰੀਵਿਊ ਨਹੀਂ ਕੀਤਾ)।
• ਫੋਲਡਰ ਨੂੰ ਮੁੜ-ਸਕੈਨ ਕਰਨ ਲਈ ਐਕਸਪਲੋਰਰ ਰਿਫ੍ਰੈਸ਼ ਦੀ ਵਰਤੋਂ ਕਰੋ।

Git: "ਤੁਸੀਂ ਡਿਫੌਲਟ ਬ੍ਰਾਂਚ 'ਤੇ ਹੋ"

ਪੁੱਲ ਬੇਨਤੀ ਖੋਲ੍ਹਣ ਲਈ ਏਕੀਕ੍ਰਿਤ ਕਰੋ ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ ਕਾਰਜਕਾਰੀ ਬ੍ਰਾਂਚ ਖੋਲ੍ਹੋ ਜਾਂ ਬਣਾਓ।

ਅਜੇ ਵੀ ਫਸੇ ਹੋ? support@deepcerebra.ai ਨਾਲ ਸੰਪਰਕ ਕਰੋ।

23 DeepCerebra Discovery — ਆਪਣੇ ਡੇਟਾ ਅਤੇ ਦਸਤਾਵੇਜ਼ਾਂ ਤੋਂ ਪੁੱਛੋ

Discovery ਤੁਹਾਡੇ ਡੇਟਾਬੇਸਾਂ ਅਤੇ ਦਸਤਾਵੇਜ਼ਾਂ ਲਈ ਇੱਕ ਖੋਜੀ ਚੈਟਬੋਟ ਹੈ। ਇੱਕ ਸਿੰਗਲ ਪੁੱਛਗਿੱਛ ਨਾਲ ਜਵਾਬ ਦੇਣ ਦੀ ਬਜਾਏ, ਇਹ ਇੱਕ ਵਿਸ਼ਲੇਸ਼ਕ ਵਾਂਗ ਕੰਮ ਕਰਦਾ ਹੈ: ਇਹ ਕਲਪਨਾਵਾਂ ਬਣਾਉਂਦਾ ਹੈ, ਸੁਰੱਖਿਅਤ ਜਾਂਚਾਂ ਦੀ ਇੱਕ ਲੜੀ ਚਲਾਉਂਦਾ ਹੈ (SQL, ਗ੍ਰਾਫ, ਦਸਤਾਵੇਜ਼ ਖੋਜ, ਸਕੀਮਾ ਜਾਂਚ, ਵੈੱਬ ਪੁਸ਼ਟੀ), ਉਹਨਾਂ ਵਿਆਖਿਆਵਾਂ ਨੂੰ ਛਾਂਟਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਸਬੂਤ ਰੱਦ ਕਰਦੇ ਹਨ, ਅਤੇ ਚਾਰਟ ਅਤੇ ਇੱਕ ਪਾਰਦਰਸ਼ੀ ਲਾਗਤ ਰਸੀਦ ਦੇ ਨਾਲ ਇੱਕ ਠੋਸ ਜਵਾਬ ਤਿਆਰ ਕਰਦਾ ਹੈ। ਇਸਨੂੰ ਐਕਟੀਵਿਟੀ ਰੇਲ ਵਿੱਚ ਕੰਪਾਸ ਆਈਕਨ (/app/discovery) ਤੋਂ ਖੋਲ੍ਹੋ।

23.1 ਸਪੇਸ — ਤੁਹਾਡਾ ਕਿਊਰੇਟ ਕੀਤਾ ਸਕੋਪ

ਇੱਕ Space ਉਹ ਸਭ ਕੁਝ ਬੰਡਲ ਕਰਦਾ ਹੈ ਜਿਸਦੀ ਇੱਕ ਪੁੱਛਗਿੱਛ ਦੀ ਲਾਈਨ ਨੂੰ ਲੋੜ ਹੁੰਦੀ ਹੈ: ਡੇਟਾਬੇਸ ਕਨੈਕਸ਼ਨ, ਦਸਤਾਵੇਜ਼ ਸੰਗ੍ਰਹਿ, ਵਿਸ਼ਲੇਸ਼ਕ ਲਈ ਨਿਰਦੇਸ਼, ਅਤੇ ਬਜਟ। + New space ਨਾਲ ਇੱਕ ਬਣਾਓ, ਫਿਰ ਸੱਜੇ ਪਾਸੇ ਸੈੱਟਅੱਪ ਪੈਨਲ ਦੀ ਵਰਤੋਂ ਕਰੋ:

• ਡੇਟਾਬੇਸ ਕਨੈਕਟ ਕਰੋ — SQLite, PostgreSQL, MySQL, SQL Server, ਜਾਂ Snowflake। ਇੱਕ ਨਾਮ ਅਤੇ DSN ਦਾਖਲ ਕਰੋ, ਕਨੈਕਟੀਵਿਟੀ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਲਈ Test 'ਤੇ ਕਲਿੱਕ ਕਰੋ (ਲੇਟੈਂਸੀ ਅਤੇ ਸਰਵਰ ਸੰਸਕਰਣ ਦਿਖਾਏ ਗਏ ਹਨ), ਜਾਂ ਇੱਕ ਮੌਜੂਦਾ ਕਨੈਕਸ਼ਨ ਕੌਂਫਿਗਰੇਸ਼ਨ ਨੂੰ JSON ਵਜੋਂ ਆਯਾਤ ਕਰੋ। ਕਨੈਕਸ਼ਨ ਮੂਲ ਰੂਪ ਵਿੱਚ ਸਿਰਫ਼-ਪੜ੍ਹਨਯੋਗ ਹੁੰਦੇ ਹਨ।
• ਦਸਤਾਵੇਜ਼ ਸ਼ਾਮਲ ਕਰੋ — ਫਾਈਲਾਂ (PDF, DOCX, PPTX, Markdown, text) ਨੂੰ ਸਿੱਧੇ ਚੈਟ ਵਿੱਚ ਖਿੱਚੋ ਅਤੇ ਛੱਡੋ, ਇੱਕ URL ਪੇਸਟ ਕਰੋ, ਜਾਂ ਇੰਜਣ ਹੋਸਟ 'ਤੇ ਇੱਕ ਫੋਲਡਰ ਮਾਰਗ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰੋ। ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਚੰਕ ਕੀਤਾ, ਏਮਬੈਡ ਕੀਤਾ, ਅਤੇ ਹਾਈਬ੍ਰਿਡ ਵੈਕਟਰ + ਗਿਆਨ-ਗ੍ਰਾਫ ਖੋਜ ਲਈ ਇੰਡੈਕਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
• ਟੇਬਲ ਆਯਾਤ ਕਰੋ — ਬਿਨਾਂ ਕਿਸੇ ਡੇਟਾਬੇਸ ਦੇ ਤੁਰੰਤ ਪੁੱਛਗਿੱਛ ਕਰਨ ਲਈ CSV/JSON ਪੇਸਟ ਜਾਂ ਅੱਪਲੋਡ ਕਰੋ।
• ਵਿਸ਼ਲੇਸ਼ਕ ਨੂੰ ਸਿਖਾਓ — ਮੈਟ੍ਰਿਕ ਪਰਿਭਾਸ਼ਾਵਾਂ, ਕਾਰੋਬਾਰੀ ਨਿਯਮ ਅਤੇ ਚੇਤਾਵਨੀਆਂ, ਕਿਊਰੇਟਰ-ਪ੍ਰਵਾਨਿਤ ਭਰੋਸੇਯੋਗ ਪੁੱਛਗਿੱਛਾਂ, ਅਤੇ ਉਦਾਹਰਨ ਸਵਾਲ→ਪੁੱਛਗਿੱਛ ਜੋੜੇ ਸ਼ਾਮਲ ਕਰੋ ਤਾਂ ਜੋ ਜਵਾਬ ਤੁਹਾਡੀਆਂ ਪਰਿਭਾਸ਼ਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ।

23.2 ਇੱਕ ਸਵਾਲ ਪੁੱਛਣਾ

ਇੱਕ ਸਵਾਲ ਉਸ ਤਰੀਕੇ ਨਾਲ ਟਾਈਪ ਕਰੋ ਜਿਵੇਂ ਤੁਸੀਂ ਕਿਸੇ ਸਹਿਕਰਮੀ ਨੂੰ ਪੁੱਛੋਗੇ — ਉਦਾਹਰਨ ਲਈ "ਮਾਰਚ ਵਿੱਚ MRI ਸਕੈਨ ਦੀ ਮਾਤਰਾ ਕਿਉਂ ਘਟੀ?"। ਜਾਂਚ ਬੋਰਡ ਪੂਰੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਲਾਈਵ ਸਟ੍ਰੀਮ ਕਰਦਾ ਹੈ:

• ਕਲਪਨਾਵਾਂ — ਜਾਂਚ ਅਧੀਨ ਉਮੀਦਵਾਰ ਵਿਆਖਿਆਵਾਂ, ਹਰੇਕ ਨੂੰ ਸਬੂਤ ਆਉਣ 'ਤੇ ਸਮਰਥਿਤ, ਖੰਡਿਤ, ਜਾਂ ਅਨਿਸ਼ਚਿਤ ਵਜੋਂ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
• ਜਾਂਚਾਂ — ਹਰ ਪੁੱਛਗਿੱਛ ਜੋ ਵਿਸ਼ਲੇਸ਼ਕ ਚਲਾਉਂਦਾ ਹੈ, ਉਸਦੀ ਸਥਿਤੀ ਦੇ ਨਾਲ; ਪੂਰੀ ਪਾਰਦਰਸ਼ਤਾ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ SQL/Cypher ਦਿਖਾਇਆ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਹਰ ਸਟੇਟਮੈਂਟ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਤੋਂ ਪਹਿਲਾਂ ਸਿਰਫ਼-ਪੜ੍ਹਨਯੋਗ ਗਾਰਡ ਨਿਯਮਾਂ ਨੂੰ ਪਾਸ ਕਰਦੀ ਹੈ।
• ਸਬੂਤ — ਨਤੀਜੇ ਵਾਲੀਆਂ ਟੇਬਲਾਂ ਅਤੇ ਦਸਤਾਵੇਜ਼ਾਂ ਦੇ ਅੰਸ਼, ਅੰਤਿਮ ਜਵਾਬ ਵਿੱਚ ਨੰਬਰ ਦੁਆਰਾ ਹਵਾਲਾ ਦਿੱਤੇ ਗਏ।
• ਜਵਾਬ + ਚਾਰਟ — ਇੱਕ ਠੋਸ ਸਿੱਟਾ ਜੋ ਉਹਨਾਂ ਵਿਆਖਿਆਵਾਂ ਦਾ ਨਾਮ ਵੀ ਦਿੰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਰੱਦ ਕਰ ਦਿੱਤਾ ਗਿਆ ਸੀ, ਨਾਲ ਹੀ ਸਬੂਤਾਂ ਤੋਂ ਬਣੇ ਆਧੁਨਿਕ ਨੀਓਨ-ਥੀਮ ਵਾਲੇ ਚਾਰਟ।
• ਰਸੀਦ — ਟੋਕਨ, ਪ੍ਰਤੀ-ਜਾਂਚ ਲਾਗਤ, ਅਤੇ ਦੌਰ, ਤੁਹਾਡੇ AI Credits 'ਤੇ ਕਿਸੇ ਹੋਰ ਏਜੰਟ ਰਨ ਵਾਂਗ ਚਾਰਜ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।

ਫਾਲੋ-ਅੱਪ ਸਵਾਲ ਉਸੇ ਥ੍ਰੈਡ ਨੂੰ ਜਾਰੀ ਰੱਖਦੇ ਹਨ, ਤਾਂ ਜੋ ਵਿਸ਼ਲੇਸ਼ਕ ਆਪਣਾ ਸੰਦਰਭ ਬਰਕਰਾਰ ਰੱਖੇ।

23.3 ਚਾਰਟ, ਰਿਪੋਰਟਾਂ ਅਤੇ ਨਿਰਯਾਤ

ਚਾਰਟ ਜਾਂਚ ਬੋਰਡ 'ਤੇ ਇਨਲਾਈਨ ਰੈਂਡਰ ਹੁੰਦੇ ਹਨ। ਪੂਰੀ ਪੁੱਛਗਿੱਛ — ਜਵਾਬ, ਕਲਪਨਾਵਾਂ, ਸਬੂਤ, ਅਤੇ ਚਾਰਟ — ਨੂੰ ਇੱਕ ਸਵੈ-ਨਿਰਭਰ HTML ਰਿਪੋਰਟ ਜਾਂ ਇੱਕ ਪ੍ਰਿੰਟ-ਗੁਣਵੱਤਾ ਵਾਲੇ PDF ਵਜੋਂ ਡਾਊਨਲੋਡ ਕਰਨ ਲਈ Export ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜੋ ਨੀਓਨ ਡਿਜ਼ਾਈਨ ਸਿਸਟਮ ਨਾਲ ਸਟਾਈਲ ਕੀਤਾ ਗਿਆ ਹੈ।

23.4 ਬਜਟ ਅਤੇ ਲਾਗਤ ਨਿਯੰਤਰਣ

ਹਰੇਕ ਸਪੇਸ ਪ੍ਰਤੀ-ਪੁੱਛਗਿੱਛ ਬਜਟ ਰੱਖਦਾ ਹੈ: ਜਾਂਚਾਂ ਦੀ ਵੱਧ ਤੋਂ ਵੱਧ ਸੰਖਿਆ, ਜਾਂਚ ਦੌਰ, ਸਕਿੰਟ, ਅਤੇ USD। ਇੰਜਣ ਕੈਪ 'ਤੇ ਸਾਫ਼-ਸੁਥਰਾ ਰੁਕ ਜਾਂਦਾ ਹੈ ਅਤੇ ਰਿਪੋਰਟ ਕਰਦਾ ਹੈ ਕਿ ਉਸਨੇ ਹੁਣ ਤੱਕ ਕੀ ਲੱਭਿਆ ਹੈ। ਹਰ ਜਾਂਚ ਦੀ ਲਾਗਤ ਰਸੀਦ 'ਤੇ ਵੇਰਵੇ ਸਹਿਤ ਦਰਸਾਈ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਜੋ ਤੁਹਾਨੂੰ ਹਮੇਸ਼ਾ ਪਤਾ ਲੱਗੇ ਕਿ ਖਰਚ ਕਿੱਥੇ ਹੋਇਆ।

23.5 ਆਟੋਮੇਸ਼ਨ: API, SDK, Workflow Studio ਅਤੇ MCP

• REST API — UI ਜੋ ਵੀ ਕਰਦਾ ਹੈ ਉਹ /v1/discovery/* ਦੇ ਅਧੀਨ ਉਪਲਬਧ ਹੈ ਜਿਸ ਵਿੱਚ discovery ਸਕੋਪ ਵਾਲਾ ਇੱਕ PAT ਹੈ (ਇਸਨੂੰ Account → API Tokens ਦੇ ਅਧੀਨ ਬਣਾਓ)। ਸਟ੍ਰੀਮਿੰਗ ਪੁੱਛਗਿੱਛਾਂ SSE ਦੀ ਵਰਤੋਂ ਕਰਦੀਆਂ ਹਨ। ਬਾਹਰੀ ਐਗਜ਼ੀਕਿਊਟਰ Thinking API (/v1/think/*, ਸਕੋਪ think) ਰਾਹੀਂ ਸਿਰਫ਼ ਜਾਂਚ ਯੋਜਨਾਬੰਦੀ ਉਧਾਰ ਲੈ ਸਕਦੇ ਹਨ।
• Python SDK — pip install deepcerebra-discovery, ਫਿਰ DiscoveryClient(base_url, token).ask(space_id, question)।
• Workflow Studio — ਕਿਸੇ ਵੀ ਵਰਕਫਲੋ ਵਿੱਚ Discovery Ask ਸਟੇਜ (discovery.ask) ਨੂੰ ਛੱਡੋ ਤਾਂ ਜੋ ਇੱਕ ਜਾਂਚ ਨੂੰ ਪਾਈਪਲਾਈਨ ਕਦਮ ਵਜੋਂ ਚਲਾਇਆ ਜਾ ਸਕੇ; ਜਵਾਬ, ਚਾਰਟ, ਅਤੇ ਰਸੀਦ ਹੇਠਲੇ ਪੜਾਵਾਂ ਵਿੱਚ ਪ੍ਰਵਾਹ ਕਰਦੇ ਹਨ।
• MCP — ਇੰਜਣ discovery_ask ਅਤੇ discovery_list_spaces ਨੂੰ MCP ਟੂਲਜ਼ ਵਜੋਂ ਪ੍ਰਗਟ ਕਰਦਾ ਹੈ, ਤਾਂ ਜੋ ਬਾਹਰੀ MCP ਕਲਾਇੰਟ ਵੀ ਜਾਂਚਾਂ ਚਲਾ ਸਕਣ।