ਐਂਹਾਂਸਡ ਸੌਫਟਵੇਅਰ ਆਰਕੀਟੈਕਚਰ ਲਈ ਲੈਂਗਚੇਨ ਅਤੇ ਡੀਐਸਪੀਆਈ ਦੇ ਨਾਲ ਏਆਈ ਏਜੰਟਾਂ ਦਾ ਆਰਕੈਸਟ ਕਰਨਾ

ਜਾਣ-ਪਛਾਣ

ਅੱਜ ਦੇ ਤੇਜ਼-ਰਫ਼ਤਾਰ ਡਿਜ਼ੀਟਲ ਲੈਂਡਸਕੇਪ ਵਿੱਚ, ਆਰਟੀਫੀਸ਼ੀਅਲ ਇੰਟੈਲੀਜੈਂਸ (AI) ਅਤੇ ਮਸ਼ੀਨ ਲਰਨਿੰਗ (ML) ਸਮਰੱਥਾਵਾਂ ਦੇ ਏਕੀਕਰਣ ਦੇ ਨਾਲ, ਸਾਫਟਵੇਅਰ ਸਿਸਟਮ ਤੇਜ਼ੀ ਨਾਲ ਗੁੰਝਲਦਾਰ ਹੁੰਦੇ ਜਾ ਰਹੇ ਹਨ। ਨਤੀਜੇ ਵਜੋਂ, ਸਕੇਲੇਬਲ ਅਤੇ ਲਚਕੀਲੇ ਸਿਸਟਮਾਂ ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰਨਾ ਜੋ AI ਏਜੰਟਾਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਆਰਕੇਸਟ੍ਰੇਟ ਕਰ ਸਕਦੇ ਹਨ, ਸਾਫਟਵੇਅਰ ਇੰਜੀਨੀਅਰਾਂ ਲਈ ਇੱਕ ਚਿੰਤਾ ਦਾ ਵਿਸ਼ਾ ਬਣ ਗਿਆ ਹੈ। ਇਹ ਲੇਖ LangChain ਅਤੇ DSPy ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ AI ਏਜੰਟਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ 'ਤੇ ਧਿਆਨ ਕੇਂਦ੍ਰਤ ਕਰਦੇ ਹੋਏ, ਕੁਸ਼ਲ ਸਾਫਟਵੇਅਰ ਆਰਕੀਟੈਕਚਰ ਡਿਜ਼ਾਈਨ ਕਰਨ ਲਈ AI, ਸਾਫਟਵੇਅਰ ਇੰਜੀਨੀਅਰਿੰਗ, ਅਤੇ ਆਰਕੈਸਟ੍ਰੇਸ਼ਨ ਟੂਲਸ ਦੇ ਇੰਟਰਸੈਕਸ਼ਨ ਦੀ ਪੜਚੋਲ ਕਰਦਾ ਹੈ।

ਏਆਈ ਆਰਕੈਸਟ੍ਰੇਸ਼ਨ ਦੀ ਲੋੜ

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

LangChain: AI ਏਜੰਟ ਬਣਾਉਣ ਲਈ ਇੱਕ ਫਰੇਮਵਰਕ

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

DSPy: ਆਰਕੈਸਟ੍ਰੇਸ਼ਨ ਲਈ ਇੱਕ ਫਰੇਮਵਰਕ

DSPy ਡਿਸਟਰੀਬਿਊਟਡ ਸਿਸਟਮ ਬਣਾਉਣ ਲਈ ਇੱਕ ਪਾਈਥਨ ਫਰੇਮਵਰਕ ਹੈ ਜੋ ਮਲਟੀਪਲ AI ਏਜੰਟਾਂ ਨੂੰ ਆਰਕੇਸਟ੍ਰੇਟ ਕਰ ਸਕਦਾ ਹੈ। ਇਹ ਟੂਲਸ ਅਤੇ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦਾ ਇੱਕ ਸੈੱਟ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜੋ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਸਕੇਲੇਬਲ ਅਤੇ ਲਚਕੀਲੇ ਸਿਸਟਮਾਂ ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰਨ ਅਤੇ ਤੈਨਾਤ ਕਰਨ ਦੇ ਯੋਗ ਬਣਾਉਂਦੇ ਹਨ ਜੋ ਮਲਟੀਪਲ ਏਜੰਟਾਂ ਵਿਚਕਾਰ ਗੁੰਝਲਦਾਰ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰ ਸਕਦੇ ਹਨ। DSPy ਅਪਾਚੇ ਕਾਫਕਾ ਮੈਸੇਜਿੰਗ ਸਿਸਟਮ ਦੇ ਸਿਖਰ 'ਤੇ ਬਣਾਇਆ ਗਿਆ ਹੈ ਅਤੇ ਵਿਤਰਿਤ ਪ੍ਰਣਾਲੀਆਂ ਨੂੰ ਬਣਾਉਣ ਲਈ ਇੱਕ ਉੱਚ-ਪੱਧਰੀ API ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

LangChain ਅਤੇ DSPy ਨਾਲ AI ਏਜੰਟਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

LangChain ਅਤੇ DSPy ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ AI ਏਜੰਟਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਇਹਨਾਂ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰਨ ਦੀ ਲੋੜ ਹੈ:

1. ਏਜੰਟ ਆਰਕੀਟੈਕਚਰ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ: AI ਏਜੰਟ ਦੇ ਆਰਕੀਟੈਕਚਰ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ, ਜਿਸ ਵਿੱਚ ਇਨਪੁਟਸ, ਆਉਟਪੁੱਟ ਅਤੇ ਹੋਰ ਏਜੰਟਾਂ ਨਾਲ ਇੰਟਰੈਕਸ਼ਨ ਸ਼ਾਮਲ ਹਨ।
2. ਏਜੰਟ ਤਰਕ ਨੂੰ ਲਾਗੂ ਕਰੋ: LangChain ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ AI ਏਜੰਟ ਦੇ ਤਰਕ ਨੂੰ ਲਾਗੂ ਕਰੋ, ਜਿਸ ਵਿੱਚ ਤਰਕ, ਸਿੱਖਣ ਅਤੇ ਅਨੁਕੂਲਨ ਵਿਧੀ ਸ਼ਾਮਲ ਹਨ।
3. ਏਜੰਟ ਦੇ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਆਰਕੇਸਟ੍ਰੇਟ ਕਰੋ: ਸੰਚਾਰ ਪ੍ਰੋਟੋਕੋਲ ਅਤੇ ਡੇਟਾ ਐਕਸਚੇਂਜ ਵਿਧੀਆਂ ਸਮੇਤ ਮਲਟੀਪਲ AI ਏਜੰਟਾਂ ਵਿਚਕਾਰ ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਆਰਕੇਸਟ੍ਰੇਟ ਕਰਨ ਲਈ DSPy ਦੀ ਵਰਤੋਂ ਕਰੋ।
4. ਸਿਸਟਮ ਨੂੰ ਤੈਨਾਤ ਕਰੋ: ਸਿਸਟਮ ਨੂੰ ਕਲਾਉਡ ਪਲੇਟਫਾਰਮ ਜਾਂ ਕੰਟੇਨਰਾਈਜ਼ੇਸ਼ਨ ਫਰੇਮਵਰਕ, ਜਿਵੇਂ ਕਿ ਡੌਕਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤੈਨਾਤ ਕਰੋ।

ਕੋਡ ਉਦਾਹਰਨ: LangChain ਨਾਲ ਇੱਕ ਸਧਾਰਨ AI ਏਜੰਟ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

ਇੱਥੇ ਇੱਕ ਸਧਾਰਨ ਕੋਡ ਉਦਾਹਰਨ ਹੈ ਜੋ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ LangChain ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ AI ਏਜੰਟ ਨੂੰ ਕਿਵੇਂ ਲਾਗੂ ਕਰਨਾ ਹੈ: ``ਅਜਗਰ langchain ਆਯਾਤ langchain.chains ਤੋਂ LLMCchain ਆਯਾਤ ਕਰੋ

ਏਜੰਟ = langchain.Agent( input_schema={"text": str}, output_schema={"text": str}, ਚੇਨ=LLMCchain( model="davinci:instructix", ਅਧਿਕਤਮ_ਲੰਬਾਈ=2048, ਤਾਪਮਾਨ = 0.7, ), )

ਏਜੰਟ ਤਰਕ ਨੂੰ ਲਾਗੂ ਕਰੋ

def agent_logic(input_text): output_text = agent.run(input_text) ਆਉਟਪੁੱਟ_ਟੈਕਸਟ ਵਾਪਸ ਕਰੋ

ਏਜੰਟ ਦੀ ਜਾਂਚ ਕਰੋ

input_text = "ਜ਼ਿੰਦਗੀ ਦਾ ਕੀ ਅਰਥ ਹੈ?" ਆਉਟਪੁੱਟ_ਟੈਕਸਟ = ਏਜੰਟ_ਤਰਕ (ਇਨਪੁਟ_ਟੈਕਸਟ) ਪ੍ਰਿੰਟ (ਆਉਟਪੁੱਟ_ਟੈਕਸਟ) `` ਇਹ ਕੋਡ ਉਦਾਹਰਨ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਇੰਪੁੱਟ ਅਤੇ ਆਉਟਪੁੱਟ ਸਕੀਮਾਂ, ਅਤੇ ਏਜੰਟ ਦੇ ਤਰਕ ਸਮੇਤ, ਲੈਂਗਚੈਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ AI ਏਜੰਟ ਨੂੰ ਕਿਵੇਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਹੈ। ਏਜੰਟ ਨੂੰ ਇੱਕ ਲਾਰਜ ਲੈਂਗੂਏਜ ਮਾਡਲ (LLM) ਚੇਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਕਿਸਮ ਦਾ AI ਏਜੰਟ ਹੈ ਜੋ ਤਰਕ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਟੈਕਸਟ ਤਿਆਰ ਕਰ ਸਕਦਾ ਹੈ।

LangChain ਅਤੇ DSPy ਲਈ ਸਿਖਰ ਦੇ 5-10 ਸਭ ਤੋਂ ਵੱਧ ਵਰਤੀਆਂ ਜਾਣ ਵਾਲੀਆਂ ਕਮਾਂਡਾਂ/ਸਨਿਪੇਟਸ

ਇੱਥੇ LangChain ਅਤੇ DSPy ਲਈ ਸਭ ਤੋਂ ਵੱਧ ਵਰਤੀਆਂ ਜਾਣ ਵਾਲੀਆਂ 5-10 ਕਮਾਂਡਾਂ/ਸਨਿਪਟ ਹਨ:

1. langchain.Agent():: ਇੱਕ ਨਵਾਂ AI ਏਜੰਟ ਉਦਾਹਰਨ ਬਣਾਉਂਦਾ ਹੈ। ਅਜਗਰ ਏਜੰਟ = langchain.Agent( input_schema={"text": str}, output_schema={"text": str}, ਚੇਨ=LLMCchain( model="davinci:instructix", ਅਧਿਕਤਮ_ਲੰਬਾਈ=2048, ਤਾਪਮਾਨ = 0.7, ), )
2. **agent.run(): AI ਏਜੰਟ ਨੂੰ ਦਿੱਤੇ ਇਨਪੁਟ ਨਾਲ ਚਲਾਉਂਦਾ ਹੈ। ਅਜਗਰ output_text = agent.run(input_text)
3. DSPy.create_cluster(): ਵੰਡੇ ਸਿਸਟਮ ਲਈ ਨੋਡਾਂ ਦਾ ਇੱਕ ਨਵਾਂ ਕਲੱਸਟਰ ਬਣਾਉਂਦਾ ਹੈ। ਅਜਗਰ ਕਲੱਸਟਰ = DSPy.create_cluster( num_nodes=5, node_type="ਵਰਕਰ", )
4. DSPy.create_agent(): ਵੰਡੇ ਸਿਸਟਮ ਲਈ ਇੱਕ ਨਵਾਂ AI ਏਜੰਟ ਉਦਾਹਰਨ ਬਣਾਉਂਦਾ ਹੈ। ਅਜਗਰ ਏਜੰਟ = DSPy.create_agent( ਕਲੱਸਟਰ = ਕਲੱਸਟਰ, agent_type="LLM", )
5. **DSPy.deploy_agent(): AI ਏਜੰਟ ਨੂੰ ਵਿਤਰਿਤ ਸਿਸਟਮ ਵਿੱਚ ਤੈਨਾਤ ਕਰਦਾ ਹੈ। ਅਜਗਰ DSPy.deploy_agent( ਏਜੰਟ = ਏਜੰਟ, ਕਲੱਸਟਰ = ਕਲੱਸਟਰ, )
6. DSPy.get_agent_status():: AI ਏਜੰਟ ਦੀ ਸਥਿਤੀ ਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ। ਅਜਗਰ ਸਥਿਤੀ = DSPy.get_agent_status( ਏਜੰਟ = ਏਜੰਟ, ਕਲੱਸਟਰ = ਕਲੱਸਟਰ, )
7. DSPy.update_agent(): AI ਏਜੰਟ ਨੂੰ ਨਵੇਂ ਡੇਟਾ ਜਾਂ ਪੈਰਾਮੀਟਰਾਂ ਨਾਲ ਅੱਪਡੇਟ ਕਰਦਾ ਹੈ। ਅਜਗਰ DSPy.update_agent( ਏਜੰਟ = ਏਜੰਟ, ਕਲੱਸਟਰ = ਕਲੱਸਟਰ, new_data={"text": "ਨਵਾਂ ਇਨਪੁਟ ਟੈਕਸਟ"}, )
8. DSPy.delete_agent():: ਵੰਡੇ ਸਿਸਟਮ ਤੋਂ AI ਏਜੰਟ ਨੂੰ ਮਿਟਾਉਂਦਾ ਹੈ। ਅਜਗਰ DSPy.delete_agent( ਏਜੰਟ = ਏਜੰਟ, ਕਲੱਸਟਰ = ਕਲੱਸਟਰ, )
9. DSPy.create_chain(): ਵਿਤਰਿਤ ਸਿਸਟਮ ਲਈ AI ਏਜੰਟਾਂ ਦੀ ਇੱਕ ਨਵੀਂ ਚੇਨ ਬਣਾਉਂਦਾ ਹੈ। ਅਜਗਰ ਚੇਨ = DSPy.create_chain( ਏਜੰਟ=[ਏਜੰਟ1, ਏਜੰਟ2, ਏਜੰਟ3], )
10. DSPy.deploy_chain(): AI ਏਜੰਟਾਂ ਦੀ ਲੜੀ ਨੂੰ ਵਿਤਰਿਤ ਸਿਸਟਮ ਵਿੱਚ ਤੈਨਾਤ ਕਰਦਾ ਹੈ। ਅਜਗਰ DSPy.deploy_chain( ਚੇਨ = ਚੇਨ, ਕਲੱਸਟਰ = ਕਲੱਸਟਰ, ) ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ

ਇੱਥੇ Chart.js ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ LangChain ਅਤੇ DSPy ਆਰਕੀਟੈਕਚਰ ਦਾ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਹੈ: ਜੇਸਨ { "type": "ਪਾਈਚਾਰਟ", "ਡਾਟਾ": { "labels": ["LangChain", "DSPy"], "datasets": [ { "label": "AI ਏਜੰਟ", "ਡਾਟਾ": [50, 50], "backgroundColor": ["#4CAF50", "#FF9800"] } ] }, "ਵਿਕਲਪ": { "ਸਿਰਲੇਖ": { "ਡਿਸਪਲੇ": ਸਹੀ, "text": "LangChain ਅਤੇ DSPy ਆਰਕੀਟੈਕਚਰ" }, "ਲੀਜੈਂਡ": { "ਡਿਸਪਲੇ": ਸਹੀ } } } ਇਹ ਦ੍ਰਿਸ਼ਟੀਕੋਣ LangChain ਅਤੇ DSPy ਵਿਚਕਾਰ AI ਏਜੰਟਾਂ ਦੀ ਵੰਡ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ, 50% ਏਜੰਟ LangChain 'ਤੇ ਚੱਲਦੇ ਹਨ ਅਤੇ 50% DSPy 'ਤੇ ਚੱਲਦੇ ਹਨ।

ਸਿੱਟਾ

LangChain ਅਤੇ DSPy AI ਏਜੰਟਾਂ ਨੂੰ ਬਣਾਉਣ ਅਤੇ ਆਰਕੇਸਟ੍ਰੇਟ ਕਰਨ ਲਈ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਫਰੇਮਵਰਕ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ, ਜਿਸ ਨਾਲ ਵਿਕਾਸਕਰਤਾਵਾਂ ਨੂੰ ਸਕੇਲੇਬਲ ਅਤੇ ਲਚਕੀਲੇ ਸਿਸਟਮਾਂ ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰਨ ਦੇ ਯੋਗ ਬਣਾਉਂਦੇ ਹਨ ਜੋ ਮਲਟੀਪਲ ਏਜੰਟਾਂ ਵਿਚਕਾਰ ਗੁੰਝਲਦਾਰ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕਰ ਸਕਦੇ ਹਨ। ਇਸ ਲੇਖ ਵਿੱਚ ਦੱਸੇ ਗਏ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰਕੇ, ਡਿਵੈਲਪਰ LangChain ਅਤੇ DSPy ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ AI ਏਜੰਟਾਂ ਨੂੰ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹਨ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ DSPy ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਵੰਡੇ ਸਿਸਟਮ ਵਿੱਚ ਤੈਨਾਤ ਕਰ ਸਕਦੇ ਹਨ। ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਕੋਡ ਉਦਾਹਰਨਾਂ ਅਤੇ ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ LangChain ਅਤੇ DSPy ਦੀਆਂ ਸਮਰੱਥਾਵਾਂ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਦੇ ਹਨ, ਅਤੇ ਚੋਟੀ ਦੇ 5-10 ਸਭ ਤੋਂ ਵੱਧ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਕਮਾਂਡਾਂ/ਸਨਿੱਪਟ ਡਿਵੈਲਪਰਾਂ ਲਈ ਇੱਕ ਤੇਜ਼ ਹਵਾਲਾ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।