Savaiminio gydymo programinės įrangos sistemų kūrimas naudojant kelių agentų AI architektūrą ir „LangChain“.

Savigydančios programinės įrangos sistemų kūrimas naudojant kelių agentų AI architektūrą ir „LangChain“

Įvadas

Šiandienos sparčiai besivystančioje programinės įrangos kūrimo aplinkoje savaime išsigydančių programinės įrangos sistemų kūrimas tapo esminiu reikalavimu siekiant užtikrinti sudėtingų programinės įrangos sistemų patikimumą, mastelį ir atsparumą. Tradicinės monolitinės architektūros nebepakanka, kad atitiktų šiuolaikinės programinės įrangos kūrimo reikalavimus, kai sistemos turi gebėti prisitaikyti prie kintančių reikalavimų, susidoroti su netikėtais gedimais ir greitai atsigauti po klaidų. Čia pradeda veikti kelių agentų AI architektūros ir „LangChain“, siūlančios galingą sprendimą, skirtą kurti savaiminio gydymo programinės įrangos sistemas, kurios gali mokytis, prisitaikyti ir reaguoti į kintančias sąlygas.

Kas yra kelių agentų AI architektūros?

Kelių agentų AI architektūros yra paskirstytos AI sistemos tipas, susidedantis iš kelių autonominių agentų, kurie sąveikauja tarpusavyje ir savo aplinka siekdami bendro tikslo. Kiekvienas agentas turi savo sprendimų priėmimo galimybes, žinias ir išteklius, gali bendrauti tarpusavyje, dalintis informacija, koordinuoti veiksmus ir prisitaikyti prie kintančių sąlygų.

Programinės įrangos sistemų kontekste kelių agentų AI architektūros gali būti naudojamos kuriant savigydos sistemas, kurios gali aptikti ir reaguoti į klaidas, gedimus ir kitas anomalijas realiuoju laiku. Paskirstydamos sprendimų priėmimo procesą keliems agentams, šios sistemos gali mokytis iš patirties, prisitaikyti prie kintančių sąlygų ir greitai atsigauti po klaidų.

Kas yra „LangChain“?

LangChain yra atvirojo kodo Python biblioteka, skirta kurti kelių agentų AI sistemas. Tai suteikia paprastą, lanksčią ir keičiamo dydžio sistemą sudėtingoms AI sistemoms, kurios gali mokytis, prisitaikyti ir reaguoti į kintančias sąlygas, kurti. „LangChain“ sukurta dirbti su daugybe AI sistemų, įskaitant „TensorFlow“, „PyTorch“ ir „Keras“, ir gali būti naudojama kuriant sistemas, kurios integruojasi su įvairiais duomenų šaltiniais, įskaitant duomenų bazes, API ir daiktų interneto įrenginius.

Savęs gydymo programinės įrangos sistemų kūrimas naudojant „LangChain“

Norėdami sukurti savaiminio gydymo programinės įrangos sistemą su LangChain, turime sukurti kelių agentų AI architektūrą, kuri galėtų aptikti klaidas, gedimus ir kitas anomalijas realiuoju laiku ir į jas reaguoti. Štai aukšto lygio architektūros apžvalga:

Agento dizainas: turime sukurti autonominių agentų, kurie galėtų sąveikauti tarpusavyje ir su aplinka, rinkinį, kad pasiektų bendrą tikslą. Kiekvienas agentas turi turėti savo sprendimų priėmimo galimybes, žinias ir išteklius.
Žinių grafikas: turime sukurti žinių grafiką, kuris atspindėtų ryšius tarp agentų, aplinkos ir sistemos tikslų. Šis grafikas gali būti naudojamas sprendžiant apie sistemos būklę ir priimant sprendimus.
Sprendimų priėmimas: turime įgyvendinti sprendimų priėmimo procesą, kuris leistų agentams samprotauti apie sistemos būklę ir priimti sprendimus remiantis žinių grafiku.
Veiksmo vykdymas: turime įgyvendinti veiksmo vykdymo procesą, kuris leistų agentams vykdyti savo sprendimus ir sąveikauti su aplinka.

Štai paprastas savęs gydymo programinės įrangos sistemos, sukurtos naudojant „LangChain“, pavyzdys:

importuoti langchain
iš langchain.agents importo agentas
iš langchain.llms importuoti LLM


grafikas = {
    'agentai': ['agentas1', 'agent2', 'agent3'],
    „aplinka“: [„duomenų bazė“, „API“, „IoT įrenginys“],
    "tikslai": ["aptikti klaidas", "reaguoti į nesėkmes", "atsigauti po klaidų"]
}

# Apibrėžkite sprendimų priėmimo procesą
def Decision_making (agentas, žinių_grafas):
    # Priežastis dėl sistemos būklės
    būsena = žinių_grafas['agentai'][agentas]
    # Priimkite sprendimą pagal valstybę
    sprendimas = 'atsakyti į nesėkmę'
    sprendimą grąžinti

# Apibrėžkite veiksmo vykdymo procesą
def action_execution(agentas, sprendimas):
    # Vykdykite sprendimą
    jei sprendimas == 'atsakyti į nesėkmę':
        # Atsakykite į nesėkmę
        print ("Reagavimas į nesėkmę...")
    grąžinti

# Sukurkite „LangChain“ agentą
agentas = agentas (
    name='self-healing-agent',
    Decision_making=decision_making,
    action_execution=action_execution,
    žinios_grafas=grafas
)

# Sukurkite „LangChain LLM“.
llm = LLM(
    name='self-healing-llm',
    model='davinci'
)

# Sukurkite „LangChain“ sistemą
system = langchain.System(
    agentas = agentas,
    llm = llm
)

# Paleiskite sistemą
system.run()

Šiame pavyzdyje demonstruojama paprasta savaime išsigyjanti programinės įrangos sistema, kuri gali aptikti klaidas, reaguoti į gedimus ir greitai atsigauti po klaidų. Sistema susideda iš autonominių agentų rinkinio, kurie sąveikauja tarpusavyje ir savo aplinka siekdami bendro tikslo. Agentai naudoja žinių grafiką, norėdami samprotauti apie sistemos būklę ir priimti sprendimus, pagrįstus grafiku.

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

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

„langchain.Agent()“: sukuria naują „LangChain“ agentą.
„langchain.LLM()“: sukuria naują „LangChain LLM“.
„langchain.System()“: sukuria naują „LangChain“ sistemą.
„agent.decision_making()“: vykdo agento sprendimų priėmimo procesą.
„agent.action_execution()“: vykdo agento veiksmo vykdymo procesą.
„llm.predict()“: numato, naudojant LLM.
„system.run()“: paleidžia „LangChain“ sistemą.
graph.add_node(): prideda naują mazgą į žinių grafiką.
graph.add_edge(): prideda naują briauną į žinių grafiką.
graph.remove_node(): pašalina mazgą iš žinių grafiko.

Vizualizacija

Štai paprastas žinių grafiko vizualizavimas naudojant Chart.js:

{
  "tipas": "grafas",
  "duomenys": {
    "mazgai": [
      {"id": "agent1", "label": "Agent 1"},
      {"id": "agent2", "label": "Agent 2"},
      {"id": "agent3", "label": "Agent 3"},
      {"id": "database", "label": "Database"},
      {"id": "API", "label": "API"},
      {"id": "IoT įrenginys", "etiketė": "IoT įrenginys"}
    ],
    "kraštai": [
      {"source": "agent1", "target": "database"},
      {"source": "agent2", "target": "API"},
      {"source": "agent3", "target": "IoT device"},
      {"source": "agent1", "target": "agent2"},
      {"šaltinis": "agentas2", "target": "agent3"}
    ]
  },
  "parinktys": {
    "išdėstymas": {
      "tipas": "apvalus"
    },
    "mazgai": {
      "dydis": 50
    },
    "kraštai": {
      "plotis": 2
    }
  }
}

Ši vizualizacija parodo ryšius tarp agentų, aplinkos ir sistemos tikslų.

Išvada

Savarankiško programinės įrangos sistemų kūrimas su kelių agentų AI architektūromis ir „LangChain“ siūlo galingą sprendimą, užtikrinantį sudėtingų programinės įrangos sistemų patikimumą, mastelį ir atsparumą. Paskirstydamos sprendimų priėmimo procesą keliems agentams, šios sistemos gali mokytis iš patirties, prisitaikyti prie kintančių sąlygų ir greitai atsigauti po klaidų. Naudodami „LangChain“, kūrėjai gali kurti sudėtingas AI sistemas, kurios integruojasi su įvairiais duomenų šaltiniais, įskaitant duomenų bazes, API ir daiktų interneto įrenginius. Vadovaudamiesi pavyzdiniu kodu ir naudodami 5–10 dažniausiai naudojamų komandų/fragmentų, kūrėjai gali sukurti savo savigydos programinės įrangos sistemas naudodami „LangChain“.

Savaiminio gydymo programinės įrangos sistemų kūrimas naudojant kelių agentų AI architektūrą ir „LangChain“.

Have Questions?