Kreu LangChain-agenton | B4N1

Kreu LangChain-agenton

8 months ago · b4n1 Read time: 4 min

Utili AI-agentojn por Aŭtomatigita Programaro: Integrante LangChain kaj DSPy en DevOps Pipelines

Enkonduko

La pejzaĝo pri programaro evoluas rapide, kun la kreskanta adopto de Artefarita Inteligenteco (AI) kaj Maŝina Lernado (ML) en diversaj aspektoj de la evolua vivociklo. Unu el la plej promesplenaj kampoj de apliko por AI estas en aŭtomatigo de programaro-liverprocezoj, inkluzive de telemetrio kaj kontinua integriĝo/kontinua deplojo (CI/KD). En ĉi tiu artikolo, ni esploros la rolon de AI-agentoj en aŭtomatigi programajn liverajn procezojn kaj enprofundiĝos en la praktikan efektivigon de orkestraj iloj kiel LangChain kaj DSPy.

La Rolo de AI-Agentoj en Programaro-Liveraĵo

AI-agentoj estas programoj, kiuj povas plenumi taskojn aŭtonome, farante decidojn surbaze de datumoj kaj reguloj. En la kunteksto de softvarlivero, AI-agentoj povas esti uzitaj por aŭtomatigi diversajn procezojn, kiel ekzemple:

  1. Telemetrio: AI-agentoj povas kolekti kaj analizi datumojn de diversaj fontoj, kiel aplikaĵaj protokoloj, agado-metrikoj kaj uzantsugestoj, por doni informojn pri la konduto kaj agado de la aplikaĵo.
  2. Kontinua Integriĝo: AI-agentoj povas aŭtomatigi la konstruon, teston kaj disfaldiĝon de kodaj ŝanĝoj, certigante, ke la aplikaĵo ĉiam estas en deplojebla stato.
  3. Kontinua Deplojo: AI-agentoj povas aŭtomatigi la disfaldiĝon de ŝanĝoj al produktado, reduktante la tempon kaj penon necesajn por akiri novajn funkciojn kaj korektojn al uzantoj.
  4. Monitorado kaj Atentigo: AI-agentoj povas monitori la agadon de la aplikaĵo kaj atentigi programistojn kaj funkciigistojn pri eblaj problemoj antaŭ ol ili fariĝos kritikaj.

LangChain: Kadro por Konstrui AI-Agentojn

LangChain estas Python-kadro por konstrui AI-agentojn, kiuj povas interagi kun diversaj datumfontoj kaj plenumi taskojn aŭtonome. LangChain provizas simplan kaj intuician API por konstruaj agentoj, kiuj povas:

  1. Interagi kun datumfontoj: LangChain disponigas gamon da datumfontoj, inkluzive de datumbazoj, API-oj kaj dosiersistemoj, kun kiuj agentoj povas interagi.
  2. Plevu taskojn: LangChain provizas gamon da taskoj, kiujn agentoj povas plenumi, inkluzive de tekstotraktado, bildrekono kaj natura lingvotraktado.
  3. Lernu de datumoj: LangChain provizas gamon da maŝinlernado-algoritmoj, kiujn agentoj povas uzi por lerni de datumoj.

DSPy: Kadro por Konstruado de Distribuitaj AI-Agentoj

DSPy estas Python-kadro por konstrui distribuitajn AI-agentojn, kiuj povas grimpi por renkonti la bezonojn de grandskalaj aplikoj. DSPy disponigas gamon da funkcioj, inkluzive de:

  1. Distribuita komputado: DSPy permesas al agentoj funkcii per pluraj maŝinoj, igante ĝin ideala por grandskalaj aplikoj.
  2. Data paralelismo: DSPy permesas al agentoj prilabori datumojn paralele, igante ĝin ideala por aplikoj kiuj postulas alt-efikecan komputadon.
  3. Skalebleco: DSPy permesas al agentoj grimpi por renkonti la bezonojn de grandskalaj aplikoj.

Integri LangChain kaj DSPy en DevOps Pipelines

Por integri LangChain kaj DSPy en DevOps-duktoj, ni povas uzi la sekvajn paŝojn:

  1. Instali LangChain kaj DSPy: Instalu LangChain kaj DSPy uzante pip.
pip instali langchain dspy
  1. Kreu LangChain-agenton: Kreu LangChain-agenton, kiu povas interagi kun datumfontoj kaj plenumi taskojn.
import langchain


agento = langĉeno.Agent(
    nomo = "mia_agento",
    data_sources=[langchain.DataSource("datumbazo", "mia_datumbazo")],
    taskoj=[langchain.Task("teksto_prilaborado", "mia_teksto_prilaborado")]
)
  1. Kreu DSPy-agenton: Kreu DSPy-agenton, kiu povas funkcii per pluraj maŝinoj kaj procesi datumojn paralele.
importi dspy

# Kreu DSPy-agenton
agento = dspy.Agent(
    nomo = "mia_agento",
    data_sources=[dspy.DataSource("datumbazo", "mia_datumbazo")],
    taskoj=[dspy.Task("teksto_prilaborado", "mia_teksto_prilaborado")]
)
  1. Integri LangChain kaj DSPy-agentojn: Integri la LangChain kaj DSPy-agentojn en DevOps-dukto uzante ilon kiel Jenkins aŭ GitLab CI/CD.
import langchain
importi dspy

# Kreu LangChain-agenton
langchain_agent = langĉeno.Agent(
    nomo="my_langchain_agent",
    data_sources=[langchain.DataSource("datumbazo", "mia_datumbazo")],
    taskoj=[langchain.Task("teksto_prilaborado", "mia_teksto_prilaborado")]
)

# Kreu DSPy-agenton
dspy_agent = dspy.Agent(
    nomo = "mia_dspya_agento",
    data_sources=[dspy.DataSource("datumbazo", "mia_datumbazo")],
    taskoj=[dspy.Task("teksto_prilaborado", "mia_teksto_prilaborado")]
)

# Integri la agentojn en DevOps-dukto
dukto = [
    langchain_agent,
    dspy_agent
]

Supro 5-10 Plej Uzitaj Komandoj/Fragmentoj

Jen la supraj 5-10 plej uzataj komandoj/fragaĵoj por LangChain kaj DSPy:

  1. LangChain: Kreu LangChain-agenton
import langchain

agento = langĉeno.Agent(
    nomo = "mia_agento",
    data_sources=[langchain.DataSource("datumbazo", "mia_datumbazo")],
    taskoj=[langchain.Task("teksto_prilaborado", "mia_teksto_prilaborado")]
)
  1. DSPy: Kreu DSPy-agenton
importi dspy

agento = dspy.Agent(
    nomo = "mia_agento",
    data_sources=[dspy.DataSource("datumbazo", "mia_datumbazo")],
    taskoj=[dspy.Task("teksto_prilaborado", "mia_teksto_prilaborado")]
)
  1. LangChain: Interagi kun datumfonto
import langchain

agento = langĉeno.Agent(
    nomo = "mia_agento",
    data_sources=[langchain.DataSource("datumbazo", "mia_datumbazo")],
    taskoj=[langchain.Task("teksto_prilaborado", "mia_teksto_prilaborado")]
)

datumoj = agento.datumfontoj[0].get_data()
  1. DSPy: Interagi kun datumfonto
importi dspy

agento = dspy.Agent(
    nomo = "mia_agento",
    data_sources=[dspy.DataSource("datumbazo", "mia_datumbazo")],
    taskoj=[dspy.Task("teksto_prilaborado", "mia_teksto_prilaborado")]
)

datumoj = agento.datumfontoj[0].get_data()
  1. LangChain: Plenumu taskon
import langchain

agento = langĉeno.Agent(
    nomo = "mia_agento",
    data_sources=[langchain.DataSource("datumbazo", "mia_datumbazo")],
    taskoj=[langchain.Task("teksto_prilaborado", "mia_teksto_prilaborado")]
)

rezulto = agento.taskoj[0].perform_task(datenoj)
  1. DSPy: Plenumu taskon
importi dspy

agento = dspy.Agent(
    nomo = "mia_agento",
    data_sources=[dspy.DataSource("datumbazo", "mia_datumbazo")],
    taskoj=[dspy.Task("teksto_prilaborado", "mia_teksto_prilaborado")]
)

rezulto = agento.taskoj[0].perform_task(datenoj)
  1. LangChain: Lernu de datumoj
import langchain

agento = langĉeno.Agent(
    nomo = "mia_agento",
    data_sources=[langchain.DataSource("datumbazo", "mia_datumbazo")],
    taskoj=[langchain.Task("teksto_prilaborado", "mia_teksto_prilaborado")]
)

agent.learn_from_data (datenoj)
  1. DSPy: Lernu de datumoj
importi dspy

agento = dspy.Agent(
    nomo = "mia_agento",
    data_sources=[dspy.DataSource("datumbazo", "mia_datumbazo")],
    taskoj=[dspy.Task("teksto_prilaborado", "mia_teksto_prilaborado")]
)

agent.learn_from_data (datenoj)
  1. LangChain: Integriĝu kun DevOps-dukto
import langchain

agento = langĉeno.Agent(
    nomo = "mia_agento",
    data_sources=[langchain.DataSource("datumbazo", "mia_datumbazo")],
    taskoj=[langchain.Task("teksto_prilaborado", "mia_teksto_prilaborado")]
)

dukto = [
    agento
]
  1. DSPy: Integriĝu kun DevOps-dukto
importi dspy

agento = dspy.Agent(
    nomo = "mia_agento",
    data_sources=[dspy.DataSource("datumbazo", "mia_datumbazo")],
    taskoj=[dspy.Task("teksto_prilaborado", "mia_teksto_prilaborado")]
)

dukto = [
    agento
]

Vidigo

Jen bildigo de la LangChain kaj DSPy-agentoj en DevOps-dukto:

{
  "tipo": "stango",
  "datenoj": {
    "labels": ["LangChain", "DSPy"],
    "datumaro": [
      {
        "label": "Agente",
        "datenoj": [10, 20],
        "fonoKoloro": ["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
      }
    ]
  },
  "opcioj": {
    "titolo": {
      "montri": vera,
      "text": "LangChain kaj DSPy Agentoj en DevOps Pipeline"
    },
    "skaloj": {
      "yAxes": [
        {
          "ticks": {
            "beginAtZero": vera
          }
        }
      ]
    }
  }
}

Ĉi tiu bildigo montras la LangChain- kaj DSPy-agentojn en DevOps-dukto, kun la LangChain-agento havanta 10 taskojn kaj la DSPy-agento havanta 20 taskojn.

Konkludo

En ĉi tiu artikolo, ni esploris la rolon de AI-agentoj en aŭtomatigado de programaj liveraj procezoj kaj enprofundiĝis en la praktikan efektivigon de orkestraj iloj kiel LangChain kaj DSPy. Ni vidis kiel LangChain kaj DSPy povas esti uzataj por krei AI-agentojn, kiuj povas interagi kun datumfontoj, plenumi taskojn kaj lerni de datumoj. Ni ankaŭ vidis kiel LangChain kaj DSPy povas esti integritaj en DevOps-duktoj uzante ilojn kiel Jenkins aŭ GitLab CI/CD. Kun la kreskanta adopto de AI kaj ML en programaro-disvolviĝo, LangChain kaj DSPy iĝas ĉiam pli gravaj iloj por programistoj kaj funkciigistoj serĉantaj aŭtomatigi programajn liverajn procezojn.

Have Questions?

Let's Talk

Contact me on LinkedIn