ai-agents-for-beginners

ਮਾਇਕਰੋਸਾਫਟ ਫਾਊਂਡਰੀ ਨਾਲ ਸਕੇਲ ਕਰਨ ਯੋਗ ਏਜੰਟਾਂ ਨੂੰ ਤਾਇਨਾਤ ਕਰਨਾ

Deploying Scalable Agents

ਕੋਰਸ ਦੇ ਇਸ ਤੱਕ ਦੇ ਹਿੱਸੇ ਤੱਕ ਤੁਸੀਂ ਐਜੰਟ ਬਣਾ ਚੁੱਕੇ ਹੋ ਜੋ ਤੁਹਾਡੇ ਲੈਪਟੌਪ ‘ਤੇ, ਨੋਟਬੁੱਕ ਦੇ ਅੰਦਰ ਚੱਲਦੇ ਹਨ, az login ਅਤੇ ਕੁਝ ਮਾਹੌਲ ਵਿਕਲਪਿਆਂ ਦੁਆਰਾ ਚਲਾਏ ਜਾਂਦੇ ਹਨ। ਇਹ ਸਿੱਖਣ ਦਾ ਬਿਲਕੁਲ ਠੀਕ ਤਰੀਕਾ ਹੈ। ਪਰ ਇਹ ਉਹ ਠੀਕ ਤਰੀਕਾ ਨਹੀਂ ਹੈ ਜਿਸ ਨਾਲ ਸਵੇਰੇ 3 ਵਜੇ ਹਜ਼ਾਰਾਂ ਗਾਹਕ ਆਪਣੇ ਭਰੋਸੇ ਵਾਲੇ ਏਜੰਟ ਨੂੰ ਚਲਾਉਂਦੇ ਹਨ।

ਇਹ ਪਾਠ “ਇਹ ਮੇਰੀ ਮਸ਼ੀਨ ‘ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ” ਅਤੇ “ਇਹ ਪੈਦਾਵਾਰੀ ਵਿੱਚ ਭਰੋਸੇਯੋਗ ਅਤੇ ਵਾਜਿਬ ਕੀਮਤ ‘ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ” ਵਿਚਕਾਰ ਫਰਕ ਬਾਰੇ ਹੈ। ਅਸੀਂ ਇਹ ਫਰਕ ਮਾਇਕਰੋਸਾਫਟ ਫਾਊਂਡਰੀ ਅਤੇ ਮਾਇਕਰੋਸਾਫਟ ਫਾਊਂਡਰੀ ਏਜੰਟ ਸਰਵਿਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪੂਰਾ ਕਰਦੇ ਹਾਂ, ਅਤੇ ਅਸੀਂ ਇੱਕ ਅਸਲੀ ਗਾਹਕ ਸਹਾਇਤਾ ਏਜੰਟ ਬਣਾ ਕੇ ਕਰਦੇ ਹਾਂ ਜਿਸ ਵਿੱਚ ਸੰਦ, ਪ੍ਰਾਪਤੀ, ਯਾਦਦਾਸ਼ਤ, ਮੂਲਾਂਕਣ ਅਤੇ ਨਿਗਰਾਨੀ ਹੁੰਦੀ ਹੈ।

ਜਾਣ-ਪਹਿਚਾਣ

ਇਸ ਪਾਠ ਵਿੱਚ ਦਿੱਤੇ ਜਾਣਗੇ:

ਸਿੱਖਣ ਦੇ ਲੱਕੜੇ

ਇਸ ਪਾਠ ਨੂੰ ਪੂਰਾ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਜਾਣੋਗੇ ਕਿ ਕਿਵੇਂ:

ਪੂਰਵ-ਆਵਸ਼ਕਤਾਵਾਂ

ਇਹ ਪਾਠ ਮੰਨਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਪਹਿਲਾਂ ਦੇ ਪਾਠਾਂ ਨੂੰ ਪੂਰਾ ਕਰ ਚੁੱਕੇ ਹੋ ਅਤੇ ਸਹੂਲਤ ਨਾਲ:

ਤੁਹਾਨੂੰ ਇਸਦੇ ਨਾਲ ਇਹ ਵੀ ਚਾਹੀਦਾ ਹੈ:

ਪ੍ਰੋਟੋਟਾਈਪ ਤੋਂ ਪੈਦਾਵਾਰੀ ਤੱਕ: ਅਸਲ ਵਿੱਚ ਕੀ ਬਦਲਦਾ ਹੈ

ਇੱਕ ਪ੍ਰੋਟੋਟਾਈਪ ਏਜੰਟ ਅਤੇ ਪ੍ਰੋਡਕਸ਼ਨ ਏਜੰਟ ਇੱਕੋ ਜਿਹਾ ਮੁੱਖ ਲੂਪ ਸਾਂਝਾ ਕਰਦੇ ਹਨ — ਸੋਚਣਾ, ਸੰਦਾਂ ਨੂੰ ਕਾਲ ਕਰਨਾ, ਜਵਾਬ ਦੇਣਾ। ਬਦਲਾਅ ਉਸ ਲੂਪ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਸਾਰੀਆਂ ਚੀਜ਼ਾਂ ਵਿੱਚ ਹੁੰਦਾ ਹੈ। ਮਾਡਲ ਸ਼ਾਇਦ ਉਤਪਾਦਨ ਏਜੰਟ ਦਾ 20% ਹੁੰਦਾ ਹੈ; ਬਾਕੀ 80% ਓਪਰੇਸ਼ਨਲ ਖਾਕਾ ਹੁੰਦਾ ਹੈ।

ਚਿੰਤਾ ਪ੍ਰੋਟੋਟਾਈਪ ਪ੍ਰੋਡਕਸ਼ਨ
ਹੋਸਟਿੰਗ ਤੁਹਾਡੇ ਨੋਟਬੁੱਕ ਵਿੱਚ ਚੱਲਦਾ ਹੈ ਇੱਕ ਹੋਸਟਡ ਸਰਵਿਸ ਵਜੋਂ ਚੱਲਦਾ ਹੈ, ਵਰਜਨਸ਼ੁਦ ਅਤੇ ਰੋਲ ਆਊਟ
ਪਛਾਣ ਤੁਹਾਡਾ az login ਟੋਕਨ ਸਕੋਪਡ RBAC ਵਾਲੀ ਮੈਨੇਜਡ ਪਛਾਣ
ਸਟੇਟ ਮੈਮੋਰੀ ਵਿੱਚ, ਰੀਸਟਾਰਟ ਤੇ ਖੋ ਜਾਂਦਾ ਹੈ ਬਾਹਰੀਕ੍ਰਿਤ (ਥ੍ਰੈਡ ਸਟੋਰ, ਯਾਦਦਾਸ਼ਤ ਸੇਵਾ)
ਫੇਲ੍ਹਯਰ ਤੁਸੀਂ ਟ੍ਰੇਸਬੈਕ ਵੇਖਦੇ ਹੋ ਮੁੜ ਕੋਸ਼ਿਸ਼, ਫਾਲਬੈਕ, ਡੈੱਡ-ਲੇਟਰ, ਅਲਰਟ
ਲਾਗਤ “ਇਹ ਕੁਝ ਸੈਂਟਾਂ ਦੀ ਗੱਲ ਹੈ” ਹਰ ਬੇਨਤੀ ‘ਤੇ ਟ੍ਰੈਕ ਕੀਤਾ, ਰਾਊਟ ਕੀਤਾ, ਕੈਸ਼ ਕੀਤਾ, ਬਜਟ ਕੀਤਾ
ਗੁణਵੱਤਾ ਤੁਸੀਂ ਨਤੀਜਾ ਦੇਖਦੇ ਹੋ ਹਰ ਰਿਲੀਜ਼ ਤੋਂ ਪਹਿਲਾਂ ਆਟੋਮੈਟਿਕ ਤੌਰ ‘ਤੇ ਮੂਲਾਂਕਣ ਕੀਤਾ
ਭਰੋਸਾ ਤੁਸੀਂ ਹਰ ਕਦਮ ਦੀ ਮਨਜ਼ੂਰੀ ਦਿੰਦੇ ਹੋ ਨੀਤੀ + ਖਤਰਨਾਕ ਕਾਰਵਾਈ ਲਈ ਮਨੁੱਖੀ-ਦਖਲ

ਇਸ ਸਾਰਣੀ ਨੂੰ ਯਾਦ ਰੱਖੋ। ਹੇਠਾਂ ਦਿੱਤੇ ਹਰ ਸੈਕਸ਼ਨ ਵਿੱਚੋਂ ਕੋਈ ਇੱਕ ਇਸ ਜਾਂਚ ਸੇਲ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।

ਏਜੰਟ ਤਾਇਨਾਤ ਨਮੂਨੇ

ਤਿੰਨ ਨਮੂਨੇ ਹਨ ਜੋ ਤੁਸੀਂ ਅਕਸਰ ਮਿਲਾ ਕੇ ਵਰਤੋਂਗੇ।

1. ਕਲਾਇੰਟ-ਹੋਸਟਡ ਏਜੰਟ

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

2. ਹੋਸਟਡ ਏਜੰਟ (ਫਾਊਂਡਰੀ ਏਜੰਟ ਸਰਵਿਸ)

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

3. ਏਜੰਟ ਵਰਕਫਲੋਜ਼

ਕਈ ਏਜੰਟ (ਅਤੇ ਸੰਦ) ਇੱਕ ਗ੍ਰਾਫ ਵਿੱਚ ਜੁੜਦੇ ਹਨ ਜਿਸ ਵਿੱਚ ਸਪੱਸ਼ਟ ਨਿਯੰਤਰਣ ਪ੍ਰਵਾਹ ਹੁੰਦਾ ਹੈ — ਲੜੀਵਾਰ ਕਦਮ, ਸ਼ਾਖਾ, ਮਾਨਵੀ ਮਨਜ਼ੂਰੀ ਨੋਡ, ਅਤੇ ਟਿਕਾਊ ਚੈਕਪੌਇੰਟ ਜੋ ਰੁਕ ਅਤੇ ਮੁੜ ਚੱਲ ਸਕਦੇ ਹਨ। ਇਹ ਮਾਇਕਰੋਸਾਫਟ ਏਜੰਟ ਫਰੇਮਵਰਕ ਦੀ ਵਰਕਫਲੋਜ਼ ਖੂਬੀ ਹੈ ਜੋ ਤਾਇਨਾਤ ਦੇ ਪੱਧਰ ‘ਤੇ ਲਾਗੂ ਹੁੰਦੀ ਹੈ।

flowchart TB
    subgraph P1[ਗਾਹਕ-ਹੋਸਟ ਕੀਤਾ]
        A1[ਤੁਹਾਡਾ ਐਪ ਪ੍ਰਕਿਰਿਆ] --> M1[ਮਾਡਲ ਪ੍ਰਦਾਤਾ]
    end
    subgraph P2[ਹੋਸਟ ਕੀਤਾ ਏਜੰਟ]
        A2[ਪਤਲਾ ਗਾਹਕ] --> F2[ਫਾਊਂਡਰੀ ਏਜੰਟ ਸੇਵਾ]
        F2 --> M2[ਮਾਡਲ + ਟੂਲ + ਥ੍ਰੈਡ ਸਟੋਰ]
    end
    subgraph P3[ਏਜੰਟ ਵਰਕਫਲੋ]
        A3[ਆਰਕੇਸਟਰੇਟਰ] --> S1[ਟ੍ਰਾਇਏਜ ਏਜੰਟ]
        S1 --> S2[ਰੀਜ਼ੋਲਵਰ ਏਜੰਟ]
        S2 --> H[ਮਨੁੱਖੀ ਮਨਜ਼ੂਰੀ ਨੋਡ]
        H --> S3[ਐਕਸ਼ਨ ਏਜੰਟ]
    end

ਮਾਇਕਰੋਸਾਫਟ ਫਾਊਂਡਰੀ ਤੇ ਏਜੰਟ ਦਾ ਜੀਵਨ ਚਕਰ

ਏਜੰਟ ਨੂੰ ਤਾਇਨਾਤ ਕਰਨਾ ਇੱਕ ਵਾਰੀ ਦਾ ਪੁਸ਼ ਨਹੀਂ ਹੁੰਦਾ। ਇਹ ਇੱਕ ਲੂਪ ਹੁੰਦਾ ਹੈ ਅਤੇ ਇਹ ਇੱਕ ਸਾਫਟਵੇਅਰ ਰਿਲੀਜ਼ ਚਕਰ ਵਾਂਗ ਲੱਗਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹੀ ਅਸਲ ਵਿੱਚ ਹੈ।

flowchart LR
    Create[ਬਣਾਓ / ਲੇਖਕ] --> Version[ਵਰਜ਼ਨ]
    Version --> Evaluate[ਆਫਲਾਈਨ ਮੁੱਲਾਂਕਣ ਕਰੋ]
    Evaluate -->|ਗੇਟ ਪਾਰ ਕਰਦਾ ਹੈ| Deploy[ਹੋਸਟ ਕੀਤਾ ਡਿਪਲੋਇ ਕਰੋ]
    Evaluate -->|ਗੇਟ ਫੇਲ ਕਰਦਾ ਹੈ| Create
    Deploy --> Observe[ਆਨਲਾਈਨ ਦੇਖੋ]
    Observe --> Improve[ਫੇਲੀਆਂ ਇਕੱਠੀਆਂ ਕਰੋ]
    Improve --> Create
    Deploy --> Retire[ਪੁਰਾਣਾ ਵਰਜ਼ਨ ਰਿਟਾਇਰ ਕਰੋ]

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

ਸਕੇਲਿੰਗ ਰਣਨੀਤੀਆਂ

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

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

ਮਾਡਲ ਰਾਊਟਿੰਗ। ਹਰ ਬੇਨਤੀ ਨੂੰ ਤੁਹਾਡੇ ਸਭ ਤੋਂ ਸਮਰੱਥ (ਅਤੇ ਮਹਿੰਗੇ) ਮਾਡਲ ਦੀ ਲੋੜ ਨਹੀਂ। ਸਧਾਰਣ ਬੇਨਤੀਆਂ — ਇਰਾਦਾ ਵਰਗੀ ਕਲਾਸੀਫਿਕੇਸ਼ਨ, ਛੋਟੇ ਤੱਥਵਾਦੀ ਜਵਾਬ — ਇੱਕ ਛੋਟੇ, ਤੇਜ਼ ਮਾਡਲ ਨੂੰ ਭੇਜੋ, ਅਤੇ ਵੱਡੇ ਮਾਡਲ ਨੂੰ ਅਸਲੀ ਸੋਚ ਲਈ ਰੱਖੋ। ਫਾਊਂਡਰੀ ਦਾ ਮਾਡਲ ਰਾਊਟਰ ਇਹ ਤੁਹਾਡੇ ਲਈ ਕਰ ਸਕਦਾ ਹੈ, ਜਾਂ ਤੁਸੀਂ ਹਲਕਾ ਫਿਲਟਰ ਖੁਦ ਬਣਾਉ। ਤੁਸੀਂ ਲੈਬ ਵਿੱਚDIY ਵਰਜ਼ਨ ਬਣਾਵੋਗੇ।

ਜਵਾਬਾਂ ਦੀ ਕੈਸ਼ਿੰਗ। ਬਹੁਤ ਸਾਰੇ ਸਹਾਇਤਾ ਪ੍ਰਸ਼ਨ ਕਰੀਬ-ਕਰੀਬ ਦੁਹਰਾਏ ਗਏ (“ਮੇਰਾ ਪਾਸਵਰਡ ਕਿਵੇਂ ਰੀਸੈੱਟ ਕਰਦਾ ਹਾਂ?”)। ਆਮ ਪ੍ਰਸ਼ਨਾਂ ਦੇ ਜਵਾਬ ਕੈਸ਼ ਕਰੋ ਅਤੇ ਇਨ੍ਹਾਂ ਨੂੰ ਮਾਡਲ ਨੂੰ ਹਿੱਟ ਕੀਤੇ ਬਿਨਾਂ ਦਿਓ। ਇੱਕ ਛੋਟੀ ਕੈਸ਼ ਹਿੱਟ ਦਰ ਵੀ ਮਹੱਤਵਪੂਰਨ ਤੌਰ ‘ਤੇ ਲਾਗਤ ਅਤੇ ਲੈਟੈਂਸੀ ਘਟਾਉਂਦੀ ਹੈ।

ਸਮਕਾਲੀਕਾਰਤਾ ਅਤੇ ਬੈਕਪ੍ਰੈਸ਼ਰ। ਮਾਡਲ ਪ੍ਰਦਾਤਿਆਂ ਦੀਆਂ ਦਰ ਸੀਮਾਵਾਂ ਹੁੰਦੀਆਂ ਹਨ। ਆਪਣੀ ਸਮਕਾਲੀਕਾਰਤਾ ‘ਤੇ ਸੀਮਾ ਲਗਾਓ, ਵਧਦੀਆਂ ਮੁੜ ਕੋਸ਼ਿਸ਼ਾਂ ਨਾਲ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰੋ ਅਤੇ ਸੋਹਣੇ ਤਰੀਕੇ ਨਾਲ ਫੇਲ੍ਹ ਹੋਵੋ (ਪੰਗ੍ਹਾ ਲੜੀਵਾਰ ਜਵਾਬ 500 ਤੋਂ ਵਧੀਆ ਹੈ)।

flowchart LR
    Q[ਯੂਜ਼ਰ ਪੁੱਛਤਾਛ] --> C{ਕੈਸ਼ ਹਿੱਟ ਹੈ?}
    C -->|ਹਾਂ| R[ਕੈਸ਼ ਕੀਤੀ ਜਵਾਬ ਵਾਪਸ ਕਰੋ]
    C -->|ਨਹੀਂ| Router{ਜਟਿਲਤਾ?}
    Router -->|ਸਧਾਰਣ| SLM[ਛੋਟਾ ਮਾਡਲ]
    Router -->|ਜਟਿਲ| LLM[ਵੱਡਾ ਮਾਡਲ]
    SLM --> Out[ਜਵਾਬ]
    LLM --> Out
    Out --> Store[ਕੈਸ਼ + ਟ੍ਰੇਸ]

ਪੈਦਾਵਾਰੀ ਵਿੱਚ ਨਿਗਰਾਨੀ

ਤੁਸੀਂ ਉਹ ਨਹੀਂ ਚਲਾ ਸਕਦੇ ਜੋ ਤੁਸੀਂ ਨਹੀਂ ਵੇਖ ਸਕਦੇ। ਜਿਵੇਂ ਕਿ ਪਾਠ 10 ਵਿੱਚ ਜ਼ਿਕਰ ਕੀਤਾ ਗਿਆ, ਮਾਇਕਰੋਸਾਫਟ ਏਜੰਟ ਫਰੇਮਵਰਕ ਸਵੈਭਾਵਿਕ ਤੌਰ ‘ਤੇ ਓਪਨਟੈਲੀਮੈਟਰੀ ਟ੍ਰੇਸਜ਼ ਜਾਰੀ ਕਰਦਾ ਹੈ — ਹਰ ਮਾਡਲ ਕਾਲ, ਟੂਲ ਕਾਲ ਅਤੇ ਓਰਕੇਸਟਰੈਸ਼ਨ ਕਦਮ ਇੱਕ ਸਪੈਨ ਬਣ ਜਾਂਦਾ ਹੈ। ਪੈਦਾਵਾਰੀ ਵਿੱਚ ਤੁਸੀਂ ਇਹ ਸਪੈਨ Microsoft Foundry (ਜਾਂ ਕੋਈ ਵੀ OTel-ਕੰਮਪੈਟਿਬਲ ਬੈਕਐਂਡ) ਨੂੰ ਐਕਸਪੋਰਟ ਕਰਦੇ ਹੋ ਤਾਂ ਜੋ ਤੁਸੀਂ:

from agent_framework.observability import get_tracer

tracer = get_tracer()

with tracer.start_as_current_span("support_request") as span:
    span.set_attribute("customer.tier", "enterprise")
    span.set_attribute("routed.model", "gpt-5-nano")
    # ਏਜੰਟ ਦੀ ਕਾਰਵਾਈ ਇਸ ਸਪੈਨ ਅੰਦਰ ਆਟੋਮੈਟਿਕ ਤੌਰ ਤੇ ਟਰੇਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ

customer.tier ਅਤੇ routed.model ਵਰਗੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਇੱਕ ਟ੍ਰੇਸ ਦੀ ਭੀੜ ਨੂੰ ਆਪਣੇ ਜਵਾਬੀ ਸਵਾਲਾਂ ਵਿੱਚ ਬਦਲ ਦੇਂਦੀਆਂ ਹਨ (“ਕੀ ਕੰਪਨੀ ਗਾਹਕ ਛੋਟੇ ਮਾਡਲ ਨੂੰ ਬਹੁਤ ਵਾਰੀ ਮਿਲ ਰਿਹਾ ਹੈ?”)।

ਲਾਗਤ ਦੀ ਬਚਤ

ਪੈਦਾਵਾਰੀ ਏਜੰਟਾਂ ਵਿੱਚ ਲਾਗਤ ਟੋਕਨਾਂ ਦੁਆਰਾ ਰੁਜੀ ਹੈ। ਤਿੰਨ ਬੁਨਿਆਦੀ ਤਰਕੇ, ਪ੍ਰਭਾਵ ਦੇ ਕ੍ਰਮ ਵਿੱਚ:

  1. ਮਾਡਲ ਦਾ ਸਹੀ ਆਕਾਰ ਚੁਣੋ। ਇੱਕ ਛੋਟਾ ਮਾਡਲ ਜੋ ਤੁਹਾਡੇ ਮੂਲਾਂਕਣ ਦਰਵਾਜ਼ੇ ਨੂੰ ਪਾਸ ਕਰਦਾ ਹੈ, ਵੱਡੇ ਮਾਡਲ ਨਾਲੋਂ ਲਗਭਗ ਹਮੇਸ਼ਾ ਸਸਤਾ ਹੁੰਦਾ ਹੈ। ਮੂਲਾਂਕਣ ਵਰਤੋਂ ਤਾਂ ਕਿ ਸਾਬਤ ਹੋ ਜਾਏ ਕਿ ਛੋਟਾ ਮਾਡਲ ਕਾਫ਼ੀ ਹੈ, ਨਾ ਕਿ ਸਭ ਤੋਂ ਵੱਡਾ ਮਾਡਲ ਡਿਵੈਲਪਮੈਂਟ ਦੀ ਵਜ੍ਹਾ ਨਾਲ ਡਿਫਾਲਟ ਬਣ ਜਾਵੇ।
  2. ਜਟਿਲਤਾ ਦੇ ਆਧਾਰ ‘ਤੇ ਰਾਊਟਿੰਗ। ਉਪਰੋਕਤ ਤਰ੍ਹਾਂ — ਵੱਡੇ ਮਾਡਲ ਦੀ ਕੀਮਤ ਸਿਰਫ ਉਹਨਾਂ ਬੇਨਤੀਆਂ ਲਈ ਭਰੋ ਜੋ ਵੱਡੇ ਮਾਡਲ ਦੀ ਸੋਚ ਕਰਦੀਆਂ ਹਨ।
  3. ਕੈਸ਼ਿੰਗ ਜ਼ੋਰਦਾਰ ਕਰੋ। ਸਭ ਤੋਂ ਸਸਤੀ ਮਾਡਲ ਕਾਲ ਉਹ ਹੈ ਜਿਸਨੂੰ ਤੁਸੀਂ ਕਦੇ ਨਹੀਂ ਕਰਦੇ।

ਮੂਲਾਂਕਣ ਗੇਟਾਂ ਅਤੇ ਲਾਗਤ ਨਿਯੰਤਰਣ ਇੱਕੋ ਹੀ ਅਭਿਆਸ ਹਨ ਜੋ ਦੋ ਵੱਖ-ਵੱਖ ਪਹਲੂਆਂ ਨੂੰ ਦੇਖਦੇ ਹਨ: ਮੂਲਾਂਕਣ ਤੁਹਾਨੂੰ ਗੁਣਵੱਤਾ ਨੀਂਹ ਦੱਸਦਾ ਹੈ, ਰਾਊਟਿੰਗ ਅਤੇ ਕੈਸ਼ਿੰਗ ਤੁਹਾਨੂੰ ਇਸ ਨੀਂਹ ਦੀ ਲਾਗਤ ਵੱਲ ਕਰੀਬ ਰੱਖਦੇ ਹਨ।

ਐਂਟਰਪ੍ਰਾਈਜ਼ ਤਾਇਨਾਤ ਵਿਚਾਰ

ਗਵਰਨੈਂਸ। ਹੋਸਟਡ ਏਜੰਟ ਫਾਊਂਡਰੀ ਦੇ RBAC, ਸਮੱਗਰੀ ਸੁਰੱਖਿਆ ਅਤੇ ਆਡੀਟ ਲਾਗਿੰਗ ਨੂੰ ਵਿਰਾਸਤ ਵਿੱਚ ਲੈਂਦੇ ਹਨ। ਹਰ ਏਜੰਟ ਨੂੰ ਉਸਦੀ ਘੱਟੋ-ਘੱਟ ਜ਼ਰੂਰੀ ਪਰਵਾਨਗੀ ਵਾਲੀ ਮੈਨੇਜਡ ਪਛਾਣ ਦਿਓ — ਸਿਰਫ ਪੜ੍ਹਨ ਲਈ ਜਾਣਕਾਰੀ ਬੇਸ, ਟਿਕਟਿੰਗ API ਲਈ ਸੀਮਿਤ ਪਹੁੰਚ, ਹੋਰ ਕੁਝ ਨਹੀਂ।

ਮਨੁੱਖੀ-ਦਾਖ਼ਲਾ। ਕੁਝ ਕਾਰਵਾਈਆਂ ਇੰਨੀ ਜ਼ਿਆਦਾ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਹੁੰਦੀਆਂ ਹਨ ਕਿ ਉਹ ਮੁੰਹਪੁਰੀ ਤੌਰ ‘ਤੇ ਆਟੋਮੈਟ ਕੀਤੀਆਂ ਨਹੀਂ ਜਾ ਸਕਦੀਆਂ — ਰਿਫੰਡ ਜਾਰੀ ਕਰਨਾ, ਖਾਤਾ ਮਿਟਾਉਣਾ, ਕਾਨੂੰਨੀ ਟੀਮ ਨੂੰ ਭੇਜਣਾ। ਮਾਇਕਰੋਸਾਫਟ ਏਜੰਟ ਫਰੇਮਵਰਕ ਮਨਜ਼ੂਰੀ-ਲੋੜੀਂਦੇ ਟੂਲਾਂ ਨੂੰ ਸਹਾਇਤਾ ਕਰਦਾ ਹੈ: ਏਜੰਟ ਕਾਰਵਾਈ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦਾ ਹੈ, ਕਾਰਜ ਰੁਕ ਜਾਂਦਾ ਹੈ, ਮਨੁੱਖੀ ਮਨਜ਼ੂਰ ਜਾਂ ਅਸਵੀਕਾਰ ਕਰਦਾ ਹੈ, ਅਤੇ ਵਰਕਫਲੋ ਮੁੜ ਚੱਲਦਾ ਹੈ। ਤੁਸੀਂ ਇਹ ਔਜਾਰ ਪਾਠ 6 ਵਿੱਚ ਦੇਖਿਆ ਸੀ; ਹੁਣ ਤੁਸੀਂ ਇਸ ਨੂੰ ਤਾਇਨਾਤ ਕਰਦੇ ਹੋ।

MCP ਪੈਦਾਵਾਰੀ ਵਿੱਚ। MCP ਤੁਹਾਡੇ ਏਜੰਟ ਨੂੰ ਬਾਹਰੀ ਟੂਲਾਂ ਨੂੰ ਇੱਕ ਸਧਾਰਣ ਇੰਟਰਫੇਸ ਰਾਹੀਂ ਵਰਤਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਪੈਦਾਵਾਰੀ ਵਿੱਚ ਹਰ MCP ਸਰਵਰ ਨੂੰ ਅਣਭਰੋਸੇਯੋਗ ਬਾਰਡਰ ਵਜੋਂ ਮਾਨੋ: ਸਰਵਰ ਦਾ ਵਰਜਨ ਫਿਕਸ ਕਰੋ, ਇਸ ਨੂੰ ਇੱਕ ਸਕੋਪਡ ਪਛਾਣ ਨਾਲ ਚਲਾਓ, ਇਸਦੇ ਨਤੀਜੇ ਚੈੱਕ ਕਰੋ, ਅਤੇ ਕਦੇ ਵੀ ਇਹਦੇ ਨਾਲ ਸੂਤਰਾਂ ਨੂੰ ਸਾਂਝਾ ਨਾ ਕਰੋ। ਇੱਕ MCP ਸਰਵਰ ਇੱਕ ਨਿਰਭਰਤਾ ਹੈ, ਅਤੇ ਨਿਰਭਰਤਾਵਾਂ ਨੂੰ ਪੈਚ, ਆਡੀਟ ਅਤੇ ਦਰ ਸੀਮਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

flowchart TB
    subgraph Dev[ਵਿਕਾਸ ਆਰਕੀਟੈਕਚਰ]
        D1[ਨੋਟਬੁੱਕ] --> D2[ਏਜੰਟ ਫਰੇਮਵਰਕ]
        D2 --> D3[ਮਾਡਲ ਪ੍ਰਦਾਤਾ]
        D2 --> D4[ਸਥਾਨਕ ਸੰਦ]
    end
    subgraph Deploy[ਡਿਪਲੋਇਮੈਂਟ ਆਰਕੀਟੈਕਚਰ]
        E1[CI ਪਾਈਪਲਾਈਨ] --> E2[ਮੁਲਾਂਕਣ ਗੇਟ]
        E2 -->|ਪਾਸ| E3[ਫਾਊਂਡਰੀ ਏਜੰਟ ਸੇਵਾ]
        E3 --> E4[ਸੰਸਕਰਣ ਵਾਲਾ ਹੋਸਟ ਕੀਤਾ ਏਜੰਟ]
    end
    subgraph Run[ਰਨਟਾਈਮ ਆਰਕੀਟੈਕਚਰ]
        F1[ਕਲਾਇੰਟ ਐਪ] --> F2[ਹੋਸਟ ਕੀਤਾ ਏਜੰਟ]
        F2 --> F3[ਮਾਡਲ ਰਾਊਟਰ]
        F2 --> F4[ਐਜ਼ੂਰ ਏਆਈ ਖੋਜ RAG]
        F2 --> F5[ਯਾਦਦਾਸ਼ਤ ਸੇਵਾ]
        F2 --> F6[MCP ਸੰਦ]
        F2 --> F7[OTel -> ਫਾਊਂਡਰੀ ਟਰੇਸਿੰਗ]
        F2 --> F8[ਮਨੁੱਖੀ ਮਨਜ਼ੂਰੀ]
    end

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

ਹੱਥ-ਕਾਰਜੀ ਲੈਬ: ਇੱਕ ਪੈਦਾਵਾਰੀ-ਤਿਆਰ ਗਾਹਕ ਸਹਾਇਤਾ ਏਜੰਟ

ਖੋਲ੍ਹੋ code_samples/16-python-agent-framework.ipynb ਅਤੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਇਸ ਨੂੰ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰੋ। ਤੁਸੀਂ ਇੱਕ ਕਾਂਟੋਸੋ ਗਾਹਕ ਸਹਾਇਤਾ ਏਜੰਟ ਠਹਿਰਾਓਗੇ ਜਿਸ ਵਿਚ ਹਰ ਪੈਦਾਵਾਰੀ ਚਿੰਤਾ ਨੂੰ ਜੋੜਿਆ ਗਿਆ ਹੈ:

  1. ਟੂਲ ਕਾਲਿੰਗ — ਆਰਡਰ ਸਥਿਤੀ ਵੇਖੋ ਅਤੇ ਸਹਾਇਤਾ ਟਿਕਟ ਖੋਲ੍ਹੋ।
  2. RAG — ਜਾਣਕਾਰੀ ਸੰਗ੍ਰਹਿ ਤੋਂ ਨੀਤੀ ਸਵਾਲਾਂ ਦੇ ਜਵਾਬ (ਅਜ਼ੁਰ AI ਸર્ચ, ਇੱਕ ਮੈਮੋਰੀ ਬੈਕਅਪ ਨਾਲ ਤਾਂ ਜੋ ਨੋਟਬੁੱਕ ਸਰਚ ਸਰੋਤ ਬਿਨਾਂ ਚੱਲੇ)।
  3. ਯਾਦਦਾਸ਼ਤ — ਗੱਲਬਾਤ ਦੇ ਵਾਰ-ਵਾਰ ਕਦਮਾਂ ਦੌਰਾਨ ਗਾਹਕ ਨੂੰ ਯਾਦ ਰੱਖੋ।
  4. ਮਾਡਲ ਰਾਊਟਿੰਗ — ਇੱਕ ਜਟਿਲਤਾ ਕਲਾਸੀਫਿਕੇਟਰ ਹਰ ਬੇਨਤੀ ਨੂੰ ਛੋਟੇ ਜਾਂ ਵੱਡੇ ਮਾਡਲ ਨੂੰ ਭੇਜਦਾ ਹੈ।
  5. ਜਵਾਬ ਕੈਸ਼ਿੰਗ — ਦੁਹਰਾਏ ਗਏ ਸਵਾਲ ਕੈਸ਼ ਤੋਂ ਪਰੋਸ਼ੇ ਜਾਂਦੇ ਹਨ।
  6. ਮਨੁੱਖੀ ਮਨਜ਼ੂਰੀ — ਇੱਕ ਸੀਮਾ ਤੋਂ ਉੱਤੇ ਰਿਫੰਡ ਮਨੁੱਖੀ ਦਸਤਖ਼ਤ ਲਈ ਰੁਕੀ ਜਾਂਦੀ ਹੈ।
  7. ਮੂਲਾਂਕਣ ਪਾਇਪਲਾਈਨ — ਇੱਕ ਛੋਟਾ ਆਫਲਾਈਨ ਟੈਸਟ ਸੈੱਟ ਏਜੰਟ ਨੂੰ ਸਕੋਰ ਕਰਦਾ ਹੈ ਅਤੇ ਇੱਕ ਰਿਲੀਜ਼ ਗੇਟ ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ।
  8. ਨਿਗਰਾਨੀਯੋਗਤਾ — ਹਰ ਬੇਨਤੀ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਓਪਨਟੈਲੀਮੈਟਰੀ ਟ੍ਰੇਸਿੰਗ।

ਲੜੀਵਾਰ ਵੇਰਵਾ

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

async def handle_support_request(query: str, customer_id: str) -> str:
    # 1. ਜਦੋਂ ਸੰਭਵ ਹੋਵੇ ਤਾਂ ਕੈਸ਼ ਤੋਂ ਸਰਵ ਕਰੋ।
    cached = response_cache.get(normalize(query))
    if cached:
        return cached

    # 2. ਖਰਚਾ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਜਟਿਲਤਾ ਅਨੁਸਾਰ ਰੂਟ ਦਿਓ।
    model = "gpt-5-nano" if is_simple(query) else "gpt-5-mini"

    # 3. ਨਿਰਾਈਕਤੀਯੋਗਤਾ ਲਈ ਏਜੰਟ ਨੂੰ ਇੱਕ ਟਰੇਸ ਸਪੈਨ ਦੇ ਅੰਦਰ ਚਲਾਓ।
    with tracer.start_as_current_span("support_request") as span:
        span.set_attribute("routed.model", model)
        span.set_attribute("customer.id", customer_id)
        response = await support_agent.run(query, model=model)

    # 4. ਕੈਸ਼ ਕਰੋ ਅਤੇ ਵਾਪਸ ਕਰੋ।
    response_cache.set(normalize(query), response.text)
    return response.text

ਜੋ ਰਿਲੀਜ਼ ਲਈ ਗੇਟ ਦੀ ਰਾਖੀ ਕਰਦਾ ਹੈ, ਉਹ ਅਜਿਹਾ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ:

async def evaluation_gate(agent, test_cases, threshold: float = 0.8) -> bool:
    passed = 0
    for case in test_cases:
        result = await agent.run(case["input"])
        if score_response(result.text, case["expected"]) >= 0.8:
            passed += 1
    pass_rate = passed / len(test_cases)
    print(f"Evaluation pass rate: {pass_rate:.0%} (gate: {threshold:.0%})")
    return pass_rate >= threshold  # ਸਿਰਫ ਉਸ ਵੇਲੇ ਡਿਪਲੋਇ ਕਰੋ ਜਦੋਂ ਗੇਟ ਪਾਸ ਹੋ ਜਾਵੇ

ਹਰ ਲਾਈਨ ਪੜ੍ਹੋ — ਨੋਟਬੁੱਕ ਇਸੇ ਲਈ ਬਟਨ ਛੋਟੇ ਰੱਖੇ ਹਨ ਤਾਂ ਜੋ ਕੋਈ ਚੀਜ਼ ਫਰੇਮਵਰਕ ਕਾਲ ਦੇ ਪਿੱਛੇ ਛੁਪਾਈ ਨਾ ਜਾਵੇ।

ਦੂਰ-ਦੂਰ ਤਯਾਰ ਹੋਏ ਏਜੰਟ ਦੀ ਸਿਗਰਮੈਂਟ ਟੈਸਟ ਨਾਲ ਜਾਂਚ

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

“ਸਫਲਤਾਪੂਰਵਕ” ਤਾਇਨਾਤ ਸਿਰਫ਼ ਇਹ ਸਾਬਤ ਕਰਦਾ ਹੈ ਕਿ ਕੰਟਰੋਲ ਪਲੇਨ ਨੇ ਪਰਿਭਾਸ਼ਾ ਸਵੀਕਾਰ ਕਰ ਲਈ ਹੈ — ਇਹ ਸਾਬਤ ਨਹੀਂ ਕਰਦਾ ਕਿ ਏਜੰਟ ਜਵਾਬ ਦੇ ਰਿਹਾ ਹੈ। ਕੋਈ ਗੁੰਮ ਹੋਈ ਨਿਰਭਰਤਾ, ਇੱਕ ਖਰਾਬ ਮਾਡਲ ਰਾਊਟਿੰਗ, ਜਾਂ ਇੱਕ ਸੇਸ਼ਨ ਦੀ ਮਿਆਦ ਖਤਮ ਹੋਣ ਨਾਲ ਹਰਿਆਾਲਾ ਤਾਇਨਾਤ ਜਿਸ ਨੂੰ ਕੁਝ ਨਹੀਂ ਮਿਲਦਾ। ਇੱਕ ਸਿਗਰਮੈਂਟ ਟੈਸਟ ਇਹ ਸੈਕੰਡਾਂ ਵਿੱਚ ਪਕੜ ਲੈਂਦਾ ਹੈ, ਹਰ ਤਾਇਨਾਤ ਉੱਤੇ, ਪੂਰੇ ਮੂਲਾਂਕਣ ਦੀ ਲਾਗਤ ਤੋਂ ਬਿਨਾਂ।

ਇਹ ਰਿਪੋਜ਼ਿਟਰੀ ਇੱਕ ਤਿਆਰ-ਮੁਹੱਈਆ ਸਿਗਰਮੈਂਟ-ਟੈਸਟ ਪਾਇਪਲਾਈਨ ਦੇ ਨਾਲ ਆਉਂਦਾ ਹੈ ਜੋ AI Smoke Test GitHub Action ‘ਤੇ ਆਧਾਰਿਤ ਹੈ:

- name: Smoke-test hosted agent
  uses: JFolberth/ai-smoketest@v1
  with:
    project_endpoint: $
    agent_name: ContosoSupportAgent
    tests_file: tests/lesson-16-smoke-tests.json

ਜਦੋਂ ਤੁਹਾਡਾ ਏਜੰਟ ਤਾਇਨਾਤ ਹੋ ਜਾਵੇ, ਤਾਂ ਤੁਸੀਂ ਇਹ ਐਕਸ਼ਨਜ਼ ਟੈਬ ਤੋਂ ਚਲਾ ਸਕਦੇ ਹੋ, ਆਪਣੇ Foundry ਪ੍ਰਾਜੈਕਟ ਐਂਡਪੌਇੰਟ ਅਤੇ ਏਜੰਟ ਨਾਮ ਸਪਲਾਈ ਕਰਦੇ ਹੋਏ। ਫੈਡਰੇਟਿਡ ਆਈਡੈਂਟੀਟੀ ਨੂੰ Foundry ਪ੍ਰਾਜੈਕਟ ਸਕੋਪ ‘ਤੇ Azure AI User ਰੋਲ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਲੇਅਰਜ਼ ਨੂੰ ਪਿਰਾਮਿਡ ਵਾਂਗ ਸੋਚੋ: ਸਮੋਕ ਟੈਸਟ (ਪਹੁੰਚਯੋਗ ਅਤੇ ਜਵਾਬ ਦੇਣ ਵਾਲੇ?) ਹਰ ਤਾਇਨਾਤ ਤੇ ਚਲਾਏ ਜਾਂਦੇ ਹਨ, ਆਫਲਾਈਨ ਮੁਲਾਂਕਣ (ਸ਼ਿਪ ਕਰਨ ਲਈ ਕਾਫੀ ਚੰਗਾ?) ਪ੍ਰਮੋਸ਼ਨ ਤੋਂ ਪਹਿਲਾਂ ਚਲਦਾ ਹੈ, ਅਤੇ ਆਨਲਾਈਨ ਮੁਲਾਂਕਣ (ਜੰਗਲ ਵਿੱਚ ਇਹ ਕਿਵੇਂ ਕਰ ਰਿਹਾ ਹੈ?) ਲਗਾਤਾਰ ਚਲਦਾ ਰਹਿਣਾ ਹੈ।

ਗਿਆਨ ਜਾਂਚ

ਅਸਾਈਨਮੈਂਟ ‘ਤੇ ਜਾਣ ਤੋਂ ਪਹਿਲਾਂ ਆਪਣੀ ਸਮਝ ਦੀ ਜਾਂਚ ਕਰੋ।

1. ਲਗਭਗ ਇੱਕ ਪ੍ਰੋਡਕਸ਼ਨ ਏਜੰਟ ਵਿੱਚ “ਮਾਡਲ” ਕਿੰਨਾ ਹਿੱਸਾ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਬਾਕੀ ਕੀ ਹੁੰਦਾ ਹੈ?

ਜਵਾਬ ਮਾਡਲ ਸਿਸਟਮ ਦਾ ਇਕ ਘੱਟ ਭਾਗ ਹੁੰਦਾ ਹੈ — ਅਕਸਰ ਲਗਭਗ 20% ਦਰਜ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਬਾਕੀ ਆਪਰੇਸ਼ਨਲ ਢਾਂਚਾ ਹੁੰਦਾ ਹੈ: ਹੋਸਟਿੰਗ ਅਤੇ ਵਰਜ਼ਨਿੰਗ, ਆਈਡੈਂਟੀਟੀ ਅਤੇ RBAC, ਬਾਹਰੀ ਰਾਜ, ਨਾਕਾਮੀ ਸੰਭਾਲ, ਲਾਗਤ ਟ੍ਰੈਕਿੰਗ, ਮੁਲਾਂਕਣ, ਅਤੇ ਮਨੁੱਖ-ਇਨ-ਲੂਪ ਕੰਟਰੋਲ। ਪ੍ਰੋਡਕਸ਼ਨ ਵੱਲ ਜਾਣਾ ਜ਼ਿਆਦਾਤਰ ਸੋਚਣ ਵਾਲਾ ਚੱਕਰ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਸਾਰਾ ਕੰਮ ਬਣਾਉਣ ਬਾਰੇ ਹੁੰਦਾ ਹੈ।

2. ਤੁਸੀਂ ਕਦੋਂ ਇੱਕ ਹੋਸਟਡ ਏਜੰਟ ਨੂੰ ਕਲਾਇੰਟ-ਹੋਸਟਡ ਏਜੰਟ ‘ਤੇ ਚੁਣੋਗੇ?

ਜਵਾਬ ਜਦੋਂ ਤੁਸੀਂ ਇਕ ਪ੍ਰਬੰਧਿਤ ਰਨਟਾਈਮ ਚਾਹੁੰਦੇ ਹੋ ਜਿਸ ਵਿੱਚ ਬਿਲਟ-ਇਨ ਟਿਕਾਊਪਨ ਹੋਵੇ (ਥ੍ਰੇਡ ਜਿਹੜੇ ਜਾਰੀ ਰਹਿੰਦੇ ਹਨ ਅਤੇ ਮੁੜ ਸ਼ੁਰੂ ਹੋ ਸਕਦੇ ਹਨ), ਨਿਗਰਾਨੀ (ਓਬਜ਼ਰਵੇਬਿਲਿਟੀ), ਸਮੱਗਰੀ ਸੁਰੱਖਿਆ, ਅਤੇ RBAC, ਅਤੇ ਤੁਸੀਂ reasoning loop ਦੇ ਕੁਝ ਘੱਟ ਪੱਧਰੀ ਨਿੰਤਰਣ ਲਈ ਓਪਰੇਸ਼ਨਲ ਸਰਫੇਸ ਏਰੀਆ ਘਟਾਉਣ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦੇ ਹੋ। ਜਦੋਂ ਤੁਸੀਂ reasoning loop 'ਤੇ ਪੂਰਾ ਨੰਤਰਣ ਚਾਹੁੰਦੇ ਹੋ ਜਾਂ ਏਜੰਟ ਨੂੰ ਮੌਜੂਦਾ ਬੈਕਐਂਡ ਵਿੱਚ ਐਂਬੈੱਡ ਕਰ ਰਹੇ ਹੋ ਤਾਂ ਕਲਾਇੰਟ-ਹੋਸਟਡ ਵਧੀਆ ਹੁੰਦਾ ਹੈ।

3. ਇੱਕ ਸਕੇਲਏਬਲ ਏਜੰਟ ਨੂੰ ਆਪਣੀ ਪ੍ਰਕਿਰਿਆ ਦੀ ਯਾਦ ਵਿੱਚ ਸਥਿਤ ਰਹਿਤ ਹੋਣਾ ਕਿਉਂ ਜਰੂਰੀ ਹੈ?

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

4. ਮਾਡਲ ਰੂਟਿੰਗ ਕਿਹੜੀ ਸਮੱਸਿਆ ਸੱਲ ਕਰਦੀ ਹੈ, ਅਤੇ ਇਹ ਮੁਲਾਂਕਣ ਨਾਲ ਕਿਵੇਂ ਜੁੜੀ ਹੋਈ ਹੈ?

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

5. “ਮੁਲਾਂਕਣ ਗੇਟ” ਕੀ ਹੈ ਅਤੇ ਇਹ ਜੀਵਨਚੱਕਰ ਵਿੱਚ ਕਿੱਥੇ ਹੁੰਦਾ ਹੈ?

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

6. ਪ੍ਰੋਡਕਸ਼ਨ ਵਿੱਚ MCP ਸਰਵਰ ਨੂੰ ਅਣਗੌਰ ਹੈ ਨਜ਼ਦੀਕੀ ਸੀਮਾ ਕਿਉਂ ਮੰਨਣਾ ਚਾਹੀਦਾ ਹੈ?

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

7. ਕਿਹਲਾ ਇੱਕਲੌਤਾ ਬਦਲਾਅ ਆਮ ਤੌਰ ਤੇ ਪ੍ਰੋਡਕਸ਼ਨ ਏਜੰਟ ਲਾਗਤ ‘ਤੇ ਸਭ ਤੋਂ ਵੱਡਾ ਪ੍ਰਭਾਵ ਪਾਂਦਾ ਹੈ, ਅਤੇ ਕਿਉਂ?

ਜਵਾਬ ਮਾਡਲ ਦਾ ਸਹੀ ਆਕਾਰ ਕੱਢਣਾ — ਸਭ ਤੋਂ ਛੋਟਾ ਐਸਾ ਮਾਡਲ ਜੋ ਅਜੇ ਵੀ ਤੁਹਾਡੇ ਮੁਲਾਂਕਣ ਗੇਟ ਨੂੰ ਪਾਰ ਕਰਦਾ ਹੋਵੇ। ਲਾਗਤ ਟੋਕਨਾਂ ਨਾਲ ਪ੍ਰਭਾਵਿਤ ਹੁੰਦੀ ਹੈ, ਅਤੇ ਇੱਕ ਛੋਟਾ ਪਰ ਕੁਆਲਟੀ ਵੱਲੋਂ ਠੀਕ ਮਾਡਲ ਲਗਭਗ ਹਮੇਸ਼ਾ ਵੱਡੇ ਮਾਡਲ ਨਾਲੋਂ ਸਸਤਾ ਹੁੰਦਾ ਹੈ। ਕੈਸ਼ਿੰਗ ਅਤੇ ਰੂਟਿੰਗ ਫਿਰ ਲਾਗਤ ਨੂੰ ਹੋਰ ਘਟਾਉਂਦੇ ਹਨ, ਪਰ ਸਹੀ ਮੂਲ ਮਾਡਲ ਦੇ ਚੋਣ ਦਾ ਸਭ ਤੋਂ ਵੱਡਾ ਪਹਿਲਾ ਅਸਰ ਹੁੰਦਾ ਹੈ।

8. ਜਿਵੇਂ customer.tier ਅਤੇ routed.model ਵਰਗੇ ਸਪੈਨ ਗੁਣ ਅਉਜ਼ਰਵੇਬਿਲਿਟੀ ਵਿੱਚ ਕੀ ਭੂਮਿਕਾ ਨਿਭਾਉਂਦੇ ਹਨ?

ਜਵਾਬ ਇਹ ਸਾਦਾ ਟ੍ਰੇਸਾਂ ਨੂੰ ਉੱਤਰਯੋਗ ਵਪਾਰਕ ਸਵਾਲਾਂ ਵਿੱਚ ਬਦਲ ਦਿੰਦੇ ਹਨ। ਗੁਣ ਬਿਨਾਂ ਤੁਹਾਡੇ ਕੋਲ ਸਿਰਫ ਸਪੈਨ ਦੀ ਇਕ ਕੰਧ ਹੁੰਦੀ ਹੈ; ਗੁਣਾਂ ਨਾਲ ਤੁਸੀਂ ਪੁੱਛ ਸਕਦੇ ਹੋ "ਕੀ ਉਦਯੋਗਿਕ ਗ੍ਰਾਹਕ ਬਹੁਤ ਵਾਰ ਛੋਟੇ ਮਾਡਲ ਵੱਲ ਰੂਟ ਕੀਤੇ ਜਾ ਰਹੇ ਹਨ?" ਜਾਂ "ਕਿਹੜਾ ਮਾਡਲ ਸਾਡੀਆਂ ਸਭ ਤੋਂ ਹੌਲੀ ਬੇਨਤੀਆਂ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ?" ਗੁਣ ਸੇ ਹਨ ਜਿਨ੍ਹਾਂ ਨਾਲ ਤੁਸੀਂ ਟੈਲੀਮੇਟਰੀ ਨੂੰ ਉਹਨਾਂ ਮਾਪਾਂ 'ਤੇ ਭਾਗ ਕਰਦੇ ਹੋ ਜੋ ਤੁਹਾਡੇ ਆਪਰੇਸ਼ਨ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹਨ।

ਅਸਾਈਨਮੈਂਟ

ਲੈਬ ਤੋਂ ਗ੍ਰਾਹਕ ਸਹਾਇਤਾ ਏਜੰਟ ਲਵੋ ਅਤੇ ਇੱਕ ਖਾਸ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਲਈ ਇਸਨੂੰ ਮਜ਼ਬੂਤ ਬਣਾਓ: ਇੱਕ SaaS ਕੰਪਨੀ ਲਈ ਸਬਸਕ੍ਰਿਪਸ਼ਨ ਬਿਲਿੰਗ ਸਹਾਇਤਾ ਏਜੰਟ।

ਤੁਹਾਡੀ ਸਭਮਿਸ਼ਨ ਵਿੱਚ ਸ਼ਾਮਿਲ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ:

  1. ਬਿਲਿੰਗ-ਸੰਬੰਧਿਤ ਟੂਲਜ਼ ਨਾਲ ਟੂਲਜ਼ ਬਦਲੋ: get_subscription_status, get_invoice, ਅਤੇ issue_credit (50 ਡਾਲਰ ਤੋਂ ਵੱਧ ਕਰੈਡਿਟ ਲਈ ਮਨੁੱਖੀ ਮਨਜ਼ੂਰੀ ਲਾਜ਼ਮੀ ਹੈ)।
  2. ਕੰਪਨੀ ਦੀ ਰਿਫੰਡ ਨੀਤੀ, ਬਿਲਿੰਗ ਚੱਕਰ ਅਤੇ ਕੈਂਸਲੇਸ਼ਨ ਨੀਤੀ ਨੂੰ ਕਵਰ ਕਰਦੇ ਤਿੰਨ RAG ਦਸਤਾਵੇਜ਼ ਜੋੜੋ।
  3. ਮੁਲਾਂਕਣ ਸੈੱਟ ਨੂੰ ਘੱਟੋ-ਘੱਟ ਆਠ ਕੇਸਾਂ ਤਕ ਵਧਾਓ, ਜਿਸ ਵਿੱਚ ਘੱਟੋ-ਘੱਟ ਦੋ ਕੇਸ ਜਿਨ੍ਹਾਂ ਨੂੰ ਮਨੁੱਖੀ ਮਨਜ਼ੂਰੀ ਦਾ ਰਾਸਤਾ ਖੋਲ੍ਹਣਾ ਚਾਹੀਦਾ ਹੈ, ਅਤੇ ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਹਾਡਾ ਮੁਲਾਂਕਣ ਗੇਟ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਪਾਸ ਜਾਂ ਫੇਲ ਕਰਦਾ ਹੈ।
  4. ਇੱਕ ਲਾਗਤ ਰਿਪੋਰਟ ਜੋੜੋ: ਏਜੰਟ ਦੁਆਰਾ ਦਸ ਮਿਲੇ-ਜੁਲੇ ਕਿਵੇਰੀਆਂ ਚਲਾਉਣ ਤੋਂ ਬਾਅਦ, ਛੋਟੇ ਮਾਡਲ ਨੂੰ ਕਿੰਨੀਆਂ, ਵੱਡੇ ਮਾਡਲ ਨੂੰ ਕਿੰਨੀਆਂ ਅਤੇ ਕੈਸ਼ ਵਿੱਚੋਂ ਕਿੰਨੀਆਂ ਸਰਵ ਹੋਈਆਂ, ਪ੍ਰਿੰਟ ਕਰੋ।

ਇੱਕ ਛੋਟਾ ਪੈਰਾਗ੍ਰਾਫ ਲਿਖੋ (ਮਾਰਕਡਾਊਨ ਸੈੱਲ ਵਿੱਚ) ਜਿਸ ਵਿੱਚ ਤੁਸੀਂ ਦੱਸੋ ਕਿ ਤੁਸੀਂ ਕਿਹੜਾ ਮਾਡਲ-ਰੂਟਿੰਗ ਨਿਯਮ ਚੁਣਿਆ ਅਤੇ ਇਸਨੂੰ ਅਸਲੀ ਟ੍ਰੈਫਿਕ ਨਾਲ ਕਿਵੇਂ ਵੈਧਾਬੱਧ ਕਰੋਂਗੇ। ਇਸਦਾ ਕੋਈ ਇਕਲੌਤਾ ਸਹੀ ਜਵਾਬ ਨਹੀਂ ਹੈ — ਤੁਹਾਡੀ ਮੂਲ-ਮੁੱਲਾਂਕਣ ਇਸ ਗੱਲ ‘ਤੇ ਹੈ ਕਿ ਕੀ ਪ੍ਰੋਡਕਸ਼ਨ ਵਿਚਾਰ ਇਕਠੇ ਢੰਗ ਨਾਲ ਜੋੜੇ ਗਏ ਹਨ ਜਾਂ ਨਹੀਂ।

ਸੰਖੇਪ

ਇਸ ਪਾਠ ਵਿੱਚ ਤੁਸੀਂ Microsoft Foundry ਨਾਲ ਇੱਕ ਏਜੰਟ ਨੂੰ ਪ੍ਰੋਟੋਟਾਈਪ ਤੋਂ ਪ੍ਰੋਡਕਸ਼ਨ ਵਿੱਚ ਲਿਜਾਇਆ:

ਅਗਲਾ ਪਾਠ ਉਲਟ ਯਾਤਰਾ ਕਰਦਾ ਹੈ: ਕਲਾਊਡ ਵਿੱਚ ਏਜੰਟਾਂ ਨੂੰ ਵਧਾਉਣ ਦੀ ਥਾਂ, ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ ਇੱਕ ਹੀ ਵਿਅਕਤੀਗਤ ਡਿਵੈਲਪਰ ਮਸ਼ੀਨ ਉੱਤੇ ਲਿਆਓਗੇ ਅਤੇ ਪੂਰੀ ਤਰਾਂ ਸਥਾਨਕ ਚਲਾਓਗੇ।

ਵਾਧੂ ਸਾਧਨ

ਪਿਛਲਾ ਪਾਠ

ਕੰਪਿਊਟਰ ਯੂਜ਼ ਏਜੰਟਸ (CUA) ਬਣਾਉਣਾ

ਅਗਲਾ ਪਾਠ

ਲੋਕਲ AI ਏਜੰਟ ਬਣਾਉਣਾ

ਅਸਵੀਕਾਰੋਪਣ: ਇਸ ਦਸਤਾਵੇਜ਼ ਦਾ ਅਨੁਵਾਦ ਏਆਈ ਅਨੁਵਾਦ ਸੇਵਾ Co-op Translator ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤਾ ਗਿਆ ਹੈ। ਜਦੋਂ ਕਿ ਅਸੀਂ ਸਹੀਤਾਵਾਂ ਲਈ ਯਤਨਸ਼ੀਲ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਰੱਖੋ ਕਿ ਸਵੈਚਾਲਿਤ ਅਨੁਵਾਦਾਂ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਅਸਮੱਤਿਆਵਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਮੂਲ ਦਸਤਾਵੇਜ਼ ਆਪਣੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਅਧਿਕਾਰਕ ਸਰੋਤ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਜਰੂਰੀ ਜਾਣਕਾਰੀ ਲਈ, ਪੇਸ਼ੇਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫ਼ਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਅਸੀਂ ਇਸ ਅਨੁਵਾਦ ਦੇ ਉਪਯੋਗ ਤੋਂ ਪੈਦਾ ਹੋਣ ਵਾਲੀਆਂ ਕਿਸੇ ਵੀ ਗਲਤਫਹਿਮੀਆਂ ਜਾਂ ਗਲਤ ਵਿਆਖਿਆਵਾਂ ਲਈ ਜਵਾਬਦੇਹ ਨਹੀਂ ਹਾਂ।

This site is open source. Improve this page.