Sortu LangChain agente bat | B4N1

Sortu LangChain agente bat

8 months ago · b4n1 Read time: 4 min

** AI agenteak aprobetxatzea software automatizatua emateko: LangChain eta DSPy integratzea DevOps Pipeline-n**

Sarrera

Softwarearen garapenaren panorama azkar eboluzionatzen ari da, Adimen Artifiziala (AI) eta Machine Learning (ML) garapenaren bizi-zikloaren hainbat aspektutan hartzen ari da. AIren aplikazio-eremurik itxaropentsuenetako bat softwarea entregatzeko prozesuak automatizatzea da, telemetria eta etengabeko integrazioa/etengabeko hedapena (CI/CD) barne. Artikulu honetan, AI agenteek softwarea entregatzeko prozesuak automatizatzeko duten zeregina aztertuko dugu eta LangChain eta DSPy bezalako orkestrazio tresnen ezarpen praktikoan sakonduko dugu.

AI agenteen rola softwarearen entregan

AI agenteak zereginak modu autonomoan egin ditzaketen software programak dira, datu eta arauetan oinarritutako erabakiak hartuz. Softwarearen entregaren testuinguruan, AI agenteak hainbat prozesu automatizatzeko erabil daitezke, hala nola:

  1. Telemetria: AI agenteek hainbat iturritako datuak bildu eta azter ditzakete, hala nola aplikazioen erregistroak, errendimendu-neurriak eta erabiltzaileen iritziak, aplikazioaren portaera eta errendimenduari buruzko xehetasunak emateko.
  2. Etengabeko integrazioa: AI agenteek kode-aldaketen eraikuntza, proba eta hedapena automatiza ditzakete, aplikazioa beti zabal daitekeen egoeran dagoela ziurtatuz.
  3. Etengabeko hedapena: AI agenteek produkzioan aldaketak hedatzea automatizatu dezakete, erabiltzaileei eginbide eta konponketa berriak lortzeko behar den denbora eta esfortzua murriztuz.
  4. Segimendua eta alertak: AI-ko agenteek aplikazioaren errendimendua kontrolatu dezakete eta garatzaileei eta operadoreei arazo potentzialen berri eman diezaiekete larri bihurtu aurretik.

LangChain: AI Agenteak eraikitzeko esparrua

LangChain Python esparru bat da, hainbat datu-iturrirekin elkarreragin dezaketen AI agenteak eraikitzeko eta zereginak modu autonomoan egiteko. LangChain-ek API sinple eta intuitibo bat eskaintzen du eragileak eraikitzeko:

  1. Datu-iturriekin elkarreragin: LangChain-ek datu-iturri sorta bat eskaintzen du, datu-baseak, APIak eta fitxategi-sistemak barne, agenteekin elkarreragin dezaketen.
  2. Egin zereginak: LangChain-ek agenteek egin ditzaketen zeregin ugari eskaintzen ditu, besteak beste, testuen prozesamendua, irudien ezagutza eta hizkuntza naturalaren prozesamendua.
  3. Datuetatik ikasi: LangChain-ek agenteek datuetatik ikasteko erabil ditzaketen ikasketa automatikoko algoritmo sorta bat eskaintzen du.

DSPy: Banatutako AI Agenteak eraikitzeko esparrua

DSPy Python esparru bat da, eskala handiko aplikazioen beharrei erantzuteko eskala dezaketen AI banatutako agenteak eraikitzeko. DSPy-k funtzio ugari eskaintzen ditu, besteak beste:

  1. Informatika banatua: DSPy-k agenteei hainbat makinatan exekutatzeko aukera ematen die, eta eskala handiko aplikazioetarako aproposa da.
  2. Datuen paralelismoa: DSPy-k agenteei datuak paraleloan prozesatzeko aukera ematen die, errendimendu handiko informatika behar duten aplikazioetarako aproposa da.
  3. Eskalagarritasuna: DSPy-k agenteei eskalatzeko aukera ematen die eskala handiko aplikazioen beharrei erantzuteko.

LanChain eta DSPy integratzea DevOps Pipeline-n

LangChain eta DSPy DevOps kanalizazioetan integratzeko, urrats hauek erabil ditzakegu:

  1. Instalatu LangChain eta DSPy: Instalatu LangChain eta DSPy pip erabiliz.
pip instalatu langchain dspy
  1. Sortu LangChain agente bat: Sortu LangChain agente bat, datu-iturburuekin elkarreragin eta zereginak egin ditzakeena.
inportatu langchain


agente = langchain.Agent(
    name="nire_agentea",
    data_sources=[langchain.DataSource("datu-basea", "nire_datu-basea")],
    zereginak=[langchain.Task("testua_prozesatzea", "nire_testua_prozesatzea")]
)
  1. Sortu DSPy agente bat: Sortu DSPy agente bat hainbat makinatan exekutatu eta datuak paraleloan prozesatu ditzakeena.
inportatu dspy

# Sortu DSPy agente bat
agente = dspy.Agent(
    name="nire_agentea",
    data_sources=[dspy.DataSource("datu-basea", "nire_datu-basea")],
    zereginak=[dspy.Task("testua_prozesatzen", "nire_testua_prozesatzen")]
)
  1. Integratu LangChain eta DSPy agenteak: Integratu LangChain eta DSPy agenteak DevOps kanalizazio batean Jenkins edo GitLab CI/CD bezalako tresna bat erabiliz.
inportatu langchain
inportatu dspy

# Sortu LangChain agente bat
langchain_agent = langchain.Agent(
    name="my_langchain_agent",
    data_sources=[langchain.DataSource("datu-basea", "nire_datu-basea")],
    zereginak=[langchain.Task("testua_prozesatzea", "nire_testua_prozesatzea")]
)

# Sortu DSPy agente bat
dspy_agent = dspy.Agent(
    name="my_dspya_agent",
    data_sources=[dspy.DataSource("datu-basea", "nire_datu-basea")],
    zereginak=[dspy.Task("testua_prozesatzen", "nire_testua_prozesatzen")]
)

# Integratu eragileak DevOps kanalizazio batean
kanalizazioa = [
    langchain_agent,
    dspy_agent
]

Erabiltzen diren 5-10 komando/zati nagusiak

Hona hemen LangChain eta DSPy-rako gehien erabiltzen diren 5-10 komando/zatiketak:

  1. LangChain: Sortu LangChain agente bat
inportatu langchain

agente = langchain.Agent(
    name="nire_agentea",
    data_sources=[langchain.DataSource("datu-basea", "nire_datu-basea")],
    zereginak=[langchain.Task("testua_prozesatzea", "nire_testua_prozesatzea")]
)
  1. DSPy: Sortu DSPy agente bat
inportatu dspy

agente = dspy.Agent(
    name="nire_agentea",
    data_sources=[dspy.DataSource("datu-basea", "nire_datu-basea")],
    zereginak=[dspy.Task("testua_prozesatzen", "nire_testua_prozesatzen")]
)
  1. LangChain: interaktu datu-iturri batekin
inportatu langchain

agente = langchain.Agent(
    name="nire_agentea",
    data_sources=[langchain.DataSource("datu-basea", "nire_datu-basea")],
    zereginak=[langchain.Task("testua_prozesatzea", "nire_testua_prozesatzea")]
)

datuak = agent.data_sources[0].get_data()
  1. DSPy: interaktu datu-iturri batekin
inportatu dspy

agente = dspy.Agent(
    name="nire_agentea",
    data_sources=[dspy.DataSource("datu-basea", "nire_datu-basea")],
    zereginak=[dspy.Task("testua_prozesatzen", "nire_testua_prozesatzen")]
)

datuak = agent.data_sources[0].get_data()
  1. LangChain: Egin zeregin bat
inportatu langchain

agente = langchain.Agent(
    name="nire_agentea",
    data_sources=[langchain.DataSource("datu-basea", "nire_datu-basea")],
    zereginak=[langchain.Task("testua_prozesatzea", "nire_testua_prozesatzea")]
)

emaitza = agente.zereginak[0].egin_zereginak(datuak)
  1. DSPy: Egin zeregin bat
inportatu dspy

agente = dspy.Agent(
    name="nire_agentea",
    data_sources=[dspy.DataSource("datu-basea", "nire_datu-basea")],
    zereginak=[dspy.Task("testua_prozesatzen", "nire_testua_prozesatzen")]
)

emaitza = agente.zereginak[0].egin_zereginak(datuak)
  1. LangChain: ikasi datuetatik
inportatu langchain

agente = langchain.Agent(
    name="nire_agentea",
    data_sources=[langchain.DataSource("datu-basea", "nire_datu-basea")],
    zereginak=[langchain.Task("testua_prozesatzea", "nire_testua_prozesatzea")]
)

agent.learn_from_data(datuak)
  1. DSPy: ikasi datuetatik
inportatu dspy

agente = dspy.Agent(
    name="nire_agentea",
    data_sources=[dspy.DataSource("datu-basea", "nire_datu-basea")],
    zereginak=[dspy.Task("testua_prozesatzen", "nire_testua_prozesatzen")]
)

agent.learn_from_data(datuak)
  1. LangChain: Integratu DevOps kanalizazio batekin
inportatu langchain

agente = langchain.Agent(
    name="nire_agentea",
    data_sources=[langchain.DataSource("datu-basea", "nire_datu-basea")],
    zereginak=[langchain.Task("testua_prozesatzea", "nire_testua_prozesatzea")]
)

kanalizazioa = [
    agente
]
  1. DSPy: Integratu DevOps kanalizazio batekin
inportatu dspy

agente = dspy.Agent(
    name="nire_agentea",
    data_sources=[dspy.DataSource("datu-basea", "nire_datu-basea")],
    zereginak=[dspy.Task("testua_prozesatzen", "nire_testua_prozesatzen")]
)

kanalizazioa = [
    agente
]

Bistaratzea

Hona hemen LangChain eta DSPy agenteen bistaratzea DevOps kanalizazio batean:

{
  "mota": "barra",
  "datuak": {
    "labels": ["LangChain", "DSPy"],
    "datu multzoak": [
      {
        "label": "Agentea",
        "datuak": [10, 20],
        "backgroundColor": ["rgba (255, 99, 132, 0.2)", "rgba (54, 162, 235, 0.2)"],
        "borderColor": ["rgba (255, 99, 132, 1)", "rgba (54, 162, 235, 1)"],
        "borderWidth": 1
      }
    ]
  },
  "aukerak": {
    "izenburua": {
      "bistaratu": egia,
      "text": "LangChain eta DSPy agenteak DevOps Pipeline-n"
    },
    "eskalak": {
      "yAxes": [
        {
          "ticks": {
            "beginAtZero": egia
          }
        }
      ]
    }
  }
}

Bistaratze honek LangChain eta DSPy agenteak DevOps kanalizazio batean erakusten ditu, LangChain agenteak 10 zeregin dituela eta DSPy agenteak 20 zeregin dituela.

Ondorioa

Artikulu honetan, AI agenteek softwarea entregatzeko prozesuak automatizatzeko duten zeregina aztertu dugu eta LangChain eta DSPy bezalako orkestrazio tresnen ezarpen praktikoan sakondu dugu. LangChain eta DSPy nola erabil daitezkeen ikusi genuen datu-iturriekin elkarreragin, zereginak egin eta datuetatik ikasteko AI agenteak sortzeko. LangChain eta DSPy DevOps kanalizazioetan nola integra daitezkeen ere ikusi genuen Jenkins edo GitLab CI/CD bezalako tresnak erabiliz. Softwarearen garapenean AI eta ML gero eta gehiago hartzearekin batera, LangChain eta DSPy gero eta tresna garrantzitsuagoak bihurtzen ari dira softwarea entregatzeko prozesuak automatizatu nahi dituzten garatzaile eta operadoreentzat.

Have Questions?

Let's Talk

Contact me on LinkedIn