Sukurkite „LangChain“ agentą | B4N1

Sukurkite „LangChain“ agentą

8 months ago · b4n1 Read time: 5 min

** AI agentų panaudojimas automatizuotam programinės įrangos pristatymui: „LangChain“ ir „DSPy“ integravimas į „DevOps“ vamzdynus**

Įvadas

Programinės įrangos kūrimo aplinka sparčiai vystosi, vis dažniau pritaikant dirbtinį intelektą (AI) ir mašininį mokymąsi (ML) įvairiuose kūrimo ciklo aspektuose. Viena iš perspektyviausių AI taikymo sričių yra programinės įrangos pristatymo procesų automatizavimas, įskaitant telemetriją ir nuolatinį integravimą / nuolatinį diegimą (CI / CD). Šiame straipsnyje mes išnagrinėsime AI agentų vaidmenį automatizuojant programinės įrangos pristatymo procesus ir gilinsimės į praktinį orkestravimo įrankių, tokių kaip LangChain ir DSPy, įgyvendinimą.

AI agentų vaidmuo teikiant programinę įrangą

AI agentai yra programinės įrangos programos, kurios gali savarankiškai atlikti užduotis, priimdamos sprendimus pagal duomenis ir taisykles. Programinės įrangos pristatymo kontekste AI agentai gali būti naudojami įvairiems procesams automatizuoti, pavyzdžiui:

  1. Telemetrija: dirbtinio intelekto agentai gali rinkti ir analizuoti duomenis iš įvairių šaltinių, pvz., programų žurnalų, našumo metrikos ir naudotojų atsiliepimų, kad pateiktų įžvalgų apie programos veikimą ir našumą.
  2. Nuolatinis integravimas: AI agentai gali automatizuoti kodo pakeitimų kūrimą, testavimą ir diegimą, užtikrindami, kad programa visada būtų diegiamos būsenos.
  3. Nuolatinis diegimas: AI agentai gali automatizuoti gamybos pakeitimų diegimą, sumažindami laiką ir pastangas, kurių reikia norint gauti naudotojams naujas funkcijas ir pataisymus.
  4. Stebėjimas ir įspėjimai: AI agentai gali stebėti programos našumą ir įspėti kūrėjus bei operatorius apie galimas problemas, kol jos tampa kritinėmis.

LangChain: AI agentų kūrimo sistema

„LangChain“ yra „Python“ sistema, skirta kurti AI agentus, galinčius sąveikauti su įvairiais duomenų šaltiniais ir savarankiškai atlikti užduotis. „LangChain“ teikia paprastą ir intuityvią API statybų agentams, kurie gali:

  1. Sąveika su duomenų šaltiniais: „LangChain“ teikia įvairius duomenų šaltinius, įskaitant duomenų bazes, API ir failų sistemas, su kuriais agentai gali sąveikauti.
  2. Atlikti užduotis: „LangChain“ teikia daugybę užduočių, kurias gali atlikti agentai, įskaitant teksto apdorojimą, vaizdo atpažinimą ir natūralios kalbos apdorojimą.
  3. Mokykitės iš duomenų: „LangChain“ teikia daugybę mašininio mokymosi algoritmų, kuriuos agentai gali naudoti mokydamiesi iš duomenų.

DSPy: paskirstytų dirbtinio intelekto agentų kūrimo sistema

DSPy yra „Python“ sistema, skirta kurti paskirstytus AI agentus, kuriuos galima keisti, kad atitiktų didelio masto programų poreikius. DSPy siūlo daugybę funkcijų, įskaitant:

  1. Paskirstytasis kompiuteris: DSPy leidžia agentams veikti keliose mašinose, todėl jis idealiai tinka didelio masto programoms.
  2. Duomenų lygiagretumas: DSPy leidžia agentams lygiagrečiai apdoroti duomenis, todėl jis idealiai tinka programoms, kurioms reikalingas didelio našumo skaičiavimas.
  3. Mastelio keitimas: DSPy leidžia agentams keisti mastelį, kad atitiktų didelio masto taikomųjų programų poreikius.

LangChain ir DSPy integravimas į DevOps vamzdynus

Norėdami integruoti LangChain ir DSPy į DevOps vamzdynus, galime atlikti šiuos veiksmus:

  1. Įdiegti LangChain ir DSPy: įdiekite LangChain ir DSPy naudodami pip.
pip įdiegti langchain dspy
  1. Sukurkite „LangChain“ agentą: sukurkite „LangChain“ agentą, galintį sąveikauti su duomenų šaltiniais ir atlikti užduotis.
importuoti langchain


agentas = langchain.Agent(
    vardas = "mano_agentas",
    data_sources=[langchain.DataSource("duomenų bazė", "mano_duomenų bazė")],
    task=[langchain.Task("text_processing", "my_text_processing")]
)
  1. Sukurkite DSPy agentą: sukurkite DSPy agentą, kuris gali veikti keliuose įrenginiuose ir lygiagrečiai apdoroti duomenis.
importuoti dspy

# Sukurkite DSPy agentą
agentas = dspy.Agent(
    vardas = "mano_agentas",
    data_sources=[dspy.DataSource("duomenų bazė", "mano_duomenų bazė")],
    task=[dspy.Task("text_processing", "my_text_processing")]
)
  1. Integruokite „LangChain“ ir „DSPy“ agentus: integruokite „LangChain“ ir „DSPy“ agentus į „DevOps“ dujotiekį naudodami tokį įrankį kaip „Jenkins“ arba „GitLab“ CI / CD.
importuoti langchain
importuoti dspy

# Sukurkite „LangChain“ agentą
langchain_agent = langchain.Agent(
    name="my_langchain_agent",
    data_sources=[langchain.DataSource("duomenų bazė", "mano_duomenų bazė")],
    task=[langchain.Task("text_processing", "my_text_processing")]
)

# Sukurkite DSPy agentą
dspy_agent = dspy.Agent(
    name="my_dspya_agent",
    data_sources=[dspy.DataSource("duomenų bazė", "mano_duomenų bazė")],
    task=[dspy.Task("text_processing", "my_text_processing")]
)

# Integruokite agentus į „DevOps“ dujotiekį
vamzdynas = [
    langchain_agent,
    dspy_agent
]

5–10 dažniausiai naudojamų komandų / fragmentų

Čia yra 5–10 dažniausiai naudojamų „LangChain“ ir „DSPy“ komandų / fragmentų:

  1. LangChain: sukurkite LangChain agentą
importuoti langchain

agentas = langchain.Agent(
    vardas = "mano_agentas",
    data_sources=[langchain.DataSource("duomenų bazė", "mano_duomenų bazė")],
    task=[langchain.Task("text_processing", "my_text_processing")]
)
  1. DSPy: sukurkite DSPy agentą
importuoti dspy

agentas = dspy.Agent(
    vardas = "mano_agentas",
    data_sources=[dspy.DataSource("duomenų bazė", "mano_duomenų bazė")],
    task=[dspy.Task("text_processing", "my_text_processing")]
)
  1. LangChain: sąveikaukite su duomenų šaltiniu
importuoti langchain

agentas = langchain.Agent(
    vardas = "mano_agentas",
    data_sources=[langchain.DataSource("duomenų bazė", "mano_duomenų bazė")],
    task=[langchain.Task("text_processing", "my_text_processing")]
)

duomenys = agent.data_sources[0].get_data()
  1. DSPy: sąveikaukite su duomenų šaltiniu
importuoti dspy

agentas = dspy.Agent(
    vardas = "mano_agentas",
    data_sources=[dspy.DataSource("duomenų bazė", "mano_duomenų bazė")],
    task=[dspy.Task("text_processing", "my_text_processing")]
)

duomenys = agent.data_sources[0].get_data()
  1. LangChain: atlikite užduotį
importuoti langchain

agentas = langchain.Agent(
    vardas = "mano_agentas",
    data_sources=[langchain.DataSource("duomenų bazė", "mano_duomenų bazė")],
    task=[langchain.Task("text_processing", "my_text_processing")]
)

rezultatas = agent.tasks[0].perform_task(data)
  1. DSPy: atlikite užduotį
importuoti dspy

agentas = dspy.Agent(
    vardas = "mano_agentas",
    data_sources=[dspy.DataSource("duomenų bazė", "mano_duomenų bazė")],
    task=[dspy.Task("text_processing", "my_text_processing")]
)

rezultatas = agent.tasks[0].perform_task(data)
  1. LangChain: mokykitės iš duomenų
importuoti langchain

agentas = langchain.Agent(
    vardas = "mano_agentas",
    data_sources=[langchain.DataSource("duomenų bazė", "mano_duomenų bazė")],
    task=[langchain.Task("text_processing", "my_text_processing")]
)

agent.learn_from_data(data)
  1. DSPy: mokykitės iš duomenų
importuoti dspy

agentas = dspy.Agent(
    vardas = "mano_agentas",
    data_sources=[dspy.DataSource("duomenų bazė", "mano_duomenų bazė")],
    task=[dspy.Task("text_processing", "my_text_processing")]
)

agent.learn_from_data(data)
  1. „LangChain“: integruokite su „DevOps“ dujotiekiu
importuoti langchain

agentas = langchain.Agent(
    vardas = "mano_agentas",
    data_sources=[langchain.DataSource("duomenų bazė", "mano_duomenų bazė")],
    task=[langchain.Task("text_processing", "my_text_processing")]
)

vamzdynas = [
    agentas
]
  1. DSPy: integravimas su DevOps dujotiekiu
importuoti dspy

agentas = dspy.Agent(
    vardas = "mano_agentas",
    data_sources=[dspy.DataSource("duomenų bazė", "mano_duomenų bazė")],
    task=[dspy.Task("text_processing", "my_text_processing")]
)

vamzdynas = [
    agentas
]

Vizualizacija

Štai „DevOps“ dujotiekio „LangChain“ ir „DSPy“ agentų vizualizacija:

{
  "tipas": "juosta",
  "duomenys": {
    "labels": ["LangChain", "DSPy"],
    "duomenų rinkiniai": [
      {
        "etiketė": "Agentas",
        "duomenys": [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
      }
    ]
  },
  "parinktys": {
    "pavadinimas": {
      "display": tiesa,
      "text": "LangChain ir DSPy agentai "DevOps Pipeline"
    },
    "svarstyklės": {
      „yAxes“: [
        {
          "erkės": {
            "beginAtZero": tiesa
          }
        }
      ]
    }
  }
}

Ši vizualizacija rodo „LangChain“ ir „DSPy“ agentus „DevOps“ dujotiekyje, kai „LangChain“ agentas turi 10 užduočių, o „DSPy“ agentas turi 20 užduočių.

Išvada

Šiame straipsnyje mes ištyrėme AI agentų vaidmenį automatizuojant programinės įrangos pristatymo procesus ir gilinomės į praktinį orkestravimo įrankių, tokių kaip LangChain ir DSPy, įgyvendinimą. Matėme, kaip LangChain ir DSPy gali būti naudojami kuriant AI agentus, kurie gali sąveikauti su duomenų šaltiniais, atlikti užduotis ir mokytis iš duomenų. Taip pat matėme, kaip „LangChain“ ir „DSPy“ galima integruoti į „DevOps“ vamzdynus naudojant tokius įrankius kaip „Jenkins“ arba „GitLab CI / CD“. Vis labiau įsisavinant AI ir ML programinės įrangos kūrime, „LangChain“ ir „DSPy“ tampa vis svarbesniais įrankiais kūrėjams ir operatoriams, norintiems automatizuoti programinės įrangos pristatymo procesus.

Have Questions?

Let's Talk

Contact me on LinkedIn