LangChain ಮತ್ತು DSPy ನೊಂದಿಗೆ AI-ಚಾಲಿತ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿಯನ್ನು ಸಂಘಟಿಸುವುದು

LangChain ಮತ್ತು DSPy ನೊಂದಿಗೆ AI-ಚಾಲಿತ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿಯನ್ನು ಆಯೋಜಿಸುವುದು

ಪರಿಚಯ

ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆ (AI) ಮತ್ತು ಮೆಷಿನ್ ಲರ್ನಿಂಗ್ (ML) ತಂತ್ರಜ್ಞಾನಗಳ ಹೆಚ್ಚುತ್ತಿರುವ ಅಳವಡಿಕೆಯಿಂದ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿಯ ಭೂದೃಶ್ಯವು ವೇಗವಾಗಿ ವಿಕಸನಗೊಳ್ಳುತ್ತಿದೆ. ದೊಡ್ಡ ಭಾಷಾ ಮಾದರಿಗಳು (LLM ಗಳು) ಈ ವಿಕಾಸದ ನಿರ್ಣಾಯಕ ಅಂಶವಾಗಿದೆ, ಕೋಡ್ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಯಿಂದ ಘಟನೆಯ ತನಿಖೆಯವರೆಗೆ ವಿವಿಧ ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಈ ಲೇಖನದಲ್ಲಿ, ಸ್ವಯಂಚಾಲಿತ ಘಟನೆಯ ತನಿಖೆ ಮತ್ತು ನಿರಂತರ ಅನುಸರಣೆ ಯಾಂತ್ರೀಕರಣಕ್ಕಾಗಿ DevOps ಪರಿಕರಗಳೊಂದಿಗೆ LLM ಗಳನ್ನು ಸಂಯೋಜಿಸುವುದರ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುವ, LangChain ಮತ್ತು DSPy ಬಳಸಿಕೊಂಡು AI- ಚಾಲಿತ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿಯನ್ನು ಹೇಗೆ ಆರ್ಕೆಸ್ಟ್ರೇಟ್ ಮಾಡುವುದು ಎಂಬುದನ್ನು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ.

LangChain ಮತ್ತು DSPy ಎಂದರೇನು?

LangChain ಎಂಬುದು LLM ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸಂವಾದಾತ್ಮಕ AI ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ತೆರೆದ ಮೂಲ ಚೌಕಟ್ಟಾಗಿದೆ. ಇದು ವಿವಿಧ ಡೇಟಾ ಮೂಲಗಳೊಂದಿಗೆ LLM ಗಳನ್ನು ಸಂಯೋಜಿಸಲು ಪರಿಕರಗಳು ಮತ್ತು API ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ, ಕಸ್ಟಮ್ ಸಂವಾದಾತ್ಮಕ ಇಂಟರ್ಫೇಸ್‌ಗಳನ್ನು ರಚಿಸಲು ಡೆವಲಪರ್‌ಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. DSPy, ಮತ್ತೊಂದೆಡೆ, AI- ಚಾಲಿತ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿ ಸಾಧನಗಳನ್ನು ನಿರ್ಮಿಸಲು ಮತ್ತು ನಿಯೋಜಿಸಲು ಪೈಥಾನ್ ಲೈಬ್ರರಿಯಾಗಿದೆ. ಇದು ಡೆವಲಪರ್‌ಗಳಿಗೆ ವಿವಿಧ ಕಾರ್ಯಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುವ ಮೂಲಕ LLM ಗಳನ್ನು DevOps ಉಪಕರಣಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಲು API ಗಳು ಮತ್ತು ಸಾಧನಗಳ ಗುಂಪನ್ನು ಒದಗಿಸುತ್ತದೆ.

DevOps ಪರಿಕರಗಳೊಂದಿಗೆ LLM ಗಳನ್ನು ಏಕೆ ಸಂಯೋಜಿಸಬೇಕು?

DevOps ಪರಿಕರಗಳೊಂದಿಗೆ LLM ಗಳನ್ನು ಸಂಯೋಜಿಸುವುದು ಹಲವಾರು ಪ್ರಯೋಜನಗಳನ್ನು ನೀಡುತ್ತದೆ, ಅವುಗಳೆಂದರೆ:

ಸ್ವಯಂಚಾಲಿತ ಘಟನೆ ತನಿಖೆ: LLM ಗಳು ಘಟನೆಯ ಡೇಟಾವನ್ನು ವಿಶ್ಲೇಷಿಸಬಹುದು, ಮೂಲ ಕಾರಣಗಳನ್ನು ಗುರುತಿಸಬಹುದು ಮತ್ತು ಪರಿಹಾರಕ್ಕಾಗಿ ಶಿಫಾರಸುಗಳನ್ನು ಒದಗಿಸಬಹುದು.
ನಿರಂತರ ಅನುಸರಣೆ ಆಟೊಮೇಷನ್: LLM ಗಳು ಅನುಸರಣೆ ಡೇಟಾವನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಬಹುದು, ಅನುಸರಣೆ ಇಲ್ಲದ ಸಮಸ್ಯೆಗಳನ್ನು ಗುರುತಿಸಬಹುದು ಮತ್ತು ಪರಿಹಾರಕ್ಕಾಗಿ ಶಿಫಾರಸುಗಳನ್ನು ಒದಗಿಸಬಹುದು.
ಸುಧಾರಿತ ಕೋಡ್ ಗುಣಮಟ್ಟ: LLM ಗಳು ಕೋಡ್ ಅನ್ನು ವಿಶ್ಲೇಷಿಸಬಹುದು, ದೋಷಗಳನ್ನು ಗುರುತಿಸಬಹುದು ಮತ್ತು ಸುಧಾರಣೆಗೆ ಶಿಫಾರಸುಗಳನ್ನು ಒದಗಿಸಬಹುದು.
ವರ್ಧಿತ ಸಹಯೋಗ: LLM ಗಳು ಡೆವಲಪರ್‌ಗಳ ನಡುವೆ ಸಂವಹನವನ್ನು ಸುಗಮಗೊಳಿಸುತ್ತದೆ, ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಸಹಯೋಗಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

** ಲ್ಯಾಂಗ್‌ಚೈನ್ ಮತ್ತು ಡಿಎಸ್‌ಪಿಯನ್ನು ಸಂಯೋಜಿಸುವುದು**

LangChain ಮತ್ತು DSPy ಅನ್ನು ಸಂಯೋಜಿಸಲು, ನೀವು ಹೀಗೆ ಮಾಡಬೇಕಾಗುತ್ತದೆ:

ಅಗತ್ಯವಿರುವ ಲೈಬ್ರರಿಗಳನ್ನು ಸ್ಥಾಪಿಸಿ: ಪಿಪ್ ಬಳಸಿ LangChain ಮತ್ತು DSPy ಅನ್ನು ಸ್ಥಾಪಿಸಿ: pip install langchain dspy
ಲೈಬ್ರರಿಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳಿ: ನಿಮ್ಮ ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ LangChain ಮತ್ತು DSPy ಲೈಬ್ರರಿಗಳನ್ನು ಆಮದು ಮಾಡಿ: langchain ಅನ್ನು lc ಆಗಿ ಆಮದು ಮಾಡಿ; dspy ಅನ್ನು dsp ಆಗಿ ಆಮದು ಮಾಡಿಕೊಳ್ಳಿ
LangChain ಏಜೆಂಟ್ ಅನ್ನು ರಚಿಸಿ: lc.Agent ವರ್ಗವನ್ನು ಬಳಸಿಕೊಂಡು LangChain ಏಜೆಂಟ್ ಅನ್ನು ರಚಿಸಿ: agent = lc.Agent(model="your_model_name")
DSPy ಕ್ಲೈಂಟ್ ಅನ್ನು ರಚಿಸಿ: dsp.Client ವರ್ಗವನ್ನು ಬಳಸಿಕೊಂಡು DSPy ಕ್ಲೈಂಟ್ ಅನ್ನು ರಚಿಸಿ: client = dsp.Client()
DSPy ಕ್ಲೈಂಟ್‌ನೊಂದಿಗೆ LangChain ಏಜೆಂಟ್ ಅನ್ನು ಸಂಯೋಜಿಸಿ: dsp.Client.integrate_agent ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು DSPy ಕ್ಲೈಂಟ್‌ನೊಂದಿಗೆ LangChain ಏಜೆಂಟ್ ಅನ್ನು ಸಂಯೋಜಿಸಿ: client.integrate_agent(agent)

ಸ್ವಯಂಚಾಲಿತ ಘಟನೆ ತನಿಖೆ

LangChain ಮತ್ತು DSPy ಬಳಸಿಕೊಂಡು ಘಟನೆಯ ತನಿಖೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು, ನೀವು:

ಘಟನೆ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಿ: ಲಾಗ್‌ಗಳು, ಡೇಟಾಬೇಸ್‌ಗಳು ಮತ್ತು API ಗಳಂತಹ ವಿವಿಧ ಮೂಲಗಳಿಂದ ಘಟನೆ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಿ.
ಘಟನೆಯ ಡೇಟಾವನ್ನು ವಿಶ್ಲೇಷಿಸಿ: LangChain ಏಜೆಂಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಘಟನೆ ಡೇಟಾವನ್ನು ವಿಶ್ಲೇಷಿಸಿ, ಮೂಲ ಕಾರಣಗಳನ್ನು ಗುರುತಿಸುವುದು ಮತ್ತು ಪರಿಹಾರಕ್ಕಾಗಿ ಶಿಫಾರಸುಗಳನ್ನು ಒದಗಿಸುವುದು.
DevOps ಪರಿಕರಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಿ: JIRA, ServiceNow, ಮತ್ತು Splunk ನಂತಹ DevOps ಪರಿಕರಗಳೊಂದಿಗೆ ವಿಶ್ಲೇಷಣೆ ಫಲಿತಾಂಶಗಳನ್ನು ಸಂಯೋಜಿಸಿ.

ನಿರಂತರ ಅನುಸರಣೆ ಆಟೊಮೇಷನ್

LangChain ಮತ್ತು DSPy ಬಳಸಿಕೊಂಡು ಅನುಸರಣೆ ಮೇಲ್ವಿಚಾರಣೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು, ನೀವು:

** ಅನುಸರಣೆ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಿ**: ಡೇಟಾಬೇಸ್‌ಗಳು, API ಗಳು ಮತ್ತು ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗಳಂತಹ ವಿವಿಧ ಮೂಲಗಳಿಂದ ಅನುಸರಣೆ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಿ.
** ಅನುಸರಣೆ ಡೇಟಾವನ್ನು ವಿಶ್ಲೇಷಿಸಿ**: LangChain ಏಜೆಂಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಅನುಸರಣೆ ಡೇಟಾವನ್ನು ವಿಶ್ಲೇಷಿಸಿ, ಅನುಸರಣೆಯಿಲ್ಲದ ಸಮಸ್ಯೆಗಳನ್ನು ಗುರುತಿಸುವುದು ಮತ್ತು ಪರಿಹಾರಕ್ಕಾಗಿ ಶಿಫಾರಸುಗಳನ್ನು ಒದಗಿಸುವುದು.
DevOps ಪರಿಕರಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಿ: JIRA, ServiceNow, ಮತ್ತು Splunk ನಂತಹ DevOps ಪರಿಕರಗಳೊಂದಿಗೆ ವಿಶ್ಲೇಷಣೆ ಫಲಿತಾಂಶಗಳನ್ನು ಸಂಯೋಜಿಸಿ.

ಸುಧಾರಿತ ಕೋಡ್ ಗುಣಮಟ್ಟ

LangChain ಮತ್ತು DSPy ಬಳಸಿಕೊಂಡು ಕೋಡ್ ಗುಣಮಟ್ಟವನ್ನು ಸುಧಾರಿಸಲು, ನೀವು:

ಕೋಡ್ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಿ: ಆವೃತ್ತಿ ನಿಯಂತ್ರಣ ವ್ಯವಸ್ಥೆಗಳು, ಡೇಟಾಬೇಸ್‌ಗಳು ಮತ್ತು API ಗಳಂತಹ ವಿವಿಧ ಮೂಲಗಳಿಂದ ಕೋಡ್ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಿ.
ಕೋಡ್ ಡೇಟಾವನ್ನು ವಿಶ್ಲೇಷಿಸಿ: LangChain ಏಜೆಂಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಕೋಡ್ ಡೇಟಾವನ್ನು ವಿಶ್ಲೇಷಿಸಿ, ದೋಷಗಳನ್ನು ಗುರುತಿಸುವುದು ಮತ್ತು ಸುಧಾರಣೆಗೆ ಶಿಫಾರಸುಗಳನ್ನು ಒದಗಿಸುವುದು.
DevOps ಪರಿಕರಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಿ: JIRA, ServiceNow, ಮತ್ತು Splunk ನಂತಹ DevOps ಪರಿಕರಗಳೊಂದಿಗೆ ವಿಶ್ಲೇಷಣೆ ಫಲಿತಾಂಶಗಳನ್ನು ಸಂಯೋಜಿಸಿ.

ವರ್ಧಿತ ಸಹಯೋಗ

LangChain ಮತ್ತು DSPy ಬಳಸಿಕೊಂಡು ಸಹಯೋಗವನ್ನು ಹೆಚ್ಚಿಸಲು, ನೀವು:

ಸಂಭಾಷಣಾ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ರಚಿಸಿ: LangChain ಏಜೆಂಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸಂವಾದಾತ್ಮಕ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ರಚಿಸಿ, LLM ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಡೆವಲಪರ್‌ಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.
DevOps ಪರಿಕರಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಿ: Slack, Microsoft Teams ಮತ್ತು ಇಮೇಲ್‌ನಂತಹ DevOps ಪರಿಕರಗಳೊಂದಿಗೆ ಸಂವಾದಾತ್ಮಕ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಸಂಯೋಜಿಸಿ.

ಟಾಪ್ 5-10 ಹೆಚ್ಚು ಬಳಸಿದ ಆಜ್ಞೆಗಳು/ತುಣುಕುಗಳು

LangChain ಮತ್ತು DSPy ಗಾಗಿ ಹೆಚ್ಚು ಬಳಸಿದ 5-10 ಕಮಾಂಡ್‌ಗಳು/ತುಣುಕುಗಳು ಇಲ್ಲಿವೆ:

LangChain ಏಜೆಂಟ್ ರಚನೆ: ಏಜೆಂಟ್ = lc.Agent(model="your_model_name")
DSPy ಕ್ಲೈಂಟ್ ರಚನೆ: ಕ್ಲೈಂಟ್ = dsp.Client()
DSPy ಕ್ಲೈಂಟ್ ಜೊತೆಗೆ ಏಜೆಂಟ್ ಇಂಟಿಗ್ರೇಷನ್: client.integrate_agent(agent)
ಘಟನೆಯ ಡೇಟಾ ಸಂಗ್ರಹಣೆ: incident_data = client.collect_incident_data()
** ಅನುಸರಣೆ ಡೇಟಾ ಸಂಗ್ರಹಣೆ**: compliance_data = client.collect_compliance_data()
ಕೋಡ್ ಡೇಟಾ ಸಂಗ್ರಹಣೆ: code_data = client.collect_code_data()
ವಿಶ್ಲೇಷಣೆಯ ಫಲಿತಾಂಶಗಳ ಏಕೀಕರಣ: client.integrate_analysis_results()
ಸಂಭಾಷಣಾ ಇಂಟರ್ಫೇಸ್ ರಚನೆ: ಇಂಟರ್ಫೇಸ್ = lc.ConversationalInterface(ಏಜೆಂಟ್)
DevOps ಟೂಲ್ ಇಂಟಿಗ್ರೇಷನ್: client.integrate_devops_tools()
ದೋಷ ನಿರ್ವಹಣೆ: ಪ್ರಯತ್ನಿಸಿ: ... ಹೊರತುಪಡಿಸಿ e: print(e)

ದೃಶ್ಯೀಕರಣ

Chart.js ಅನ್ನು ಬಳಸಿಕೊಂಡು LangChain ಮತ್ತು DSPy ಆರ್ಕಿಟೆಕ್ಚರ್‌ನ ದೃಶ್ಯೀಕರಣ ಇಲ್ಲಿದೆ:

{
  "ಪ್ರಕಾರ": "ಬಾರ್",
  "ಡೇಟಾ": {
    "ಲೇಬಲ್‌ಗಳು": ["ಘಟನೆ ತನಿಖೆ", "ಅನುಸರಣೆ ಮಾನಿಟರಿಂಗ್", "ಕೋಡ್ ಗುಣಮಟ್ಟ", "ಸಹಯೋಗ"],
    "ಡೇಟಾಸೆಟ್‌ಗಳು": [
      {
        "ಲೇಬಲ್": "ಲ್ಯಾಂಗ್‌ಚೈನ್",
        "ಡೇಟಾ": [10, 8, 12, 15],
        "backgroundColor": "rgba(255, 99, 132, 0.2)",
        "borderColor": "rgba(255, 99, 132, 1)",
        "ಬಾರ್ಡರ್ ಅಗಲ": 1
      },
      {
        "ಲೇಬಲ್": "ಡಿಎಸ್ಪಿ",
        "ಡೇಟಾ": [12, 10, 15, 18],
        "backgroundColor": "rgba(54, 162, 235, 0.2)",
        "ಬಾರ್ಡರ್ ಕಲರ್": "rgba(54, 162, 235, 1)",
        "ಬಾರ್ಡರ್ ಅಗಲ": 1
      }
    ]
  },
  "ಆಯ್ಕೆಗಳು": {
    "ಶೀರ್ಷಿಕೆ": {
      "ಪ್ರದರ್ಶನ": ನಿಜ,
      "ಪಠ್ಯ": "ಲ್ಯಾಂಗ್‌ಚೈನ್ ಮತ್ತು ಡಿಎಸ್‌ಪಿ ಆರ್ಕಿಟೆಕ್ಚರ್"
    },
    "ಮಾಪಕಗಳು": {
      "yAxes": [
        {
          "ಉಣ್ಣಿ": {
            "beginAtZero": ನಿಜ
          }
        }
      ]
    }
  }
}

ಈ ದೃಶ್ಯೀಕರಣವು LangChain ಮತ್ತು DSPy ಆರ್ಕಿಟೆಕ್ಚರ್ ಅನ್ನು ತೋರಿಸುತ್ತದೆ, ಸ್ವಯಂಚಾಲಿತ ಘಟನೆ ತನಿಖೆ, ಅನುಸರಣೆ ಮೇಲ್ವಿಚಾರಣೆ, ಕೋಡ್ ಗುಣಮಟ್ಟ ಸುಧಾರಣೆ ಮತ್ತು ಸಹಯೋಗ ವರ್ಧನೆಗಾಗಿ DevOps ಪರಿಕರಗಳೊಂದಿಗೆ LLM ಗಳ ಏಕೀಕರಣವನ್ನು ಎತ್ತಿ ತೋರಿಸುತ್ತದೆ.

ತೀರ್ಮಾನ

ಕೊನೆಯಲ್ಲಿ, LangChain ಮತ್ತು DSPy AI-ಚಾಲಿತ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿಯನ್ನು ಸಂಘಟಿಸಲು ಪ್ರಬಲ ಸಂಯೋಜನೆಯನ್ನು ನೀಡುತ್ತವೆ. DevOps ಪರಿಕರಗಳೊಂದಿಗೆ LLM ಗಳನ್ನು ಸಂಯೋಜಿಸುವ ಮೂಲಕ, ಡೆವಲಪರ್‌ಗಳು ಘಟನೆಯ ತನಿಖೆ, ಅನುಸರಣೆ ಮೇಲ್ವಿಚಾರಣೆ, ಕೋಡ್ ಗುಣಮಟ್ಟ ಸುಧಾರಣೆ ಮತ್ತು ಸಹಯೋಗ ವರ್ಧನೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಬಹುದು. LangChain ಮತ್ತು DSPy ಯೊಂದಿಗೆ, ಡೆವಲಪರ್‌ಗಳು ಕಸ್ಟಮ್ ಸಂವಾದಾತ್ಮಕ ಇಂಟರ್‌ಫೇಸ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು, DevOps ಪರಿಕರಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಬಹುದು ಮತ್ತು ಸಹಯೋಗವನ್ನು ಹೆಚ್ಚಿಸಬಹುದು. ಈ ಲೇಖನದಲ್ಲಿ ವಿವರಿಸಿರುವ ಆಜ್ಞೆಗಳು ಮತ್ತು ತುಣುಕುಗಳನ್ನು ಅನುಸರಿಸುವ ಮೂಲಕ, ಡೆವಲಪರ್‌ಗಳು ಇಂದು ಲ್ಯಾಂಗ್‌ಚೈನ್ ಮತ್ತು ಡಿಎಸ್‌ಪಿಯೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಬಹುದು.

LangChain ಮತ್ತು DSPy ನೊಂದಿಗೆ AI-ಚಾಲಿತ ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿಯನ್ನು ಸಂಘಟಿಸುವುದು

Have Questions?