** AI գործակալների կազմակերպում LangChain-ի և DSPy-ի հետ ընդլայնված ծրագրային ճարտարապետության համար**

Ներածություն

Այսօրվա արագընթաց թվային լանդշաֆտում ծրագրային համակարգերը գնալով ավելի բարդ են դառնում՝ Արհեստական ինտելեկտի (AI) և մեքենայական ուսուցման (ML) կարողությունների ինտեգրմամբ: Արդյունքում, ընդլայնելի և ճկուն համակարգերի նախագծումը, որոնք կարող են արդյունավետ կերպով կազմակերպել AI գործակալները, դարձել է ծրագրային ապահովման ինժեներների հրատապ մտահոգությունը: Այս հոդվածը ուսումնասիրում է AI-ի, ծրագրային ապահովման ճարտարագիտության և նվագախմբային գործիքների խաչմերուկը՝ արդյունավետ ծրագրային ճարտարապետություններ նախագծելու համար՝ կենտրոնանալով AI գործակալների ներդրման վրա՝ օգտագործելով LangChain և DSPy:

AI նվագախմբի անհրաժեշտությունը

Ավանդական ծրագրային համակարգերը հաճախ նախագծված են մոնոլիտ ճարտարապետությամբ, որտեղ բոլոր բաղադրիչները սերտորեն զուգակցված են և միասին աշխատում են գծային ձևով: Այնուամենայնիվ, AI-ի և ML-ի գալուստով, ծրագրային համակարգերը գնալով ավելի են բաշխվում և ապակենտրոնացվում, քանի որ բազմաթիվ գործակալներ աշխատում են միասին՝ հասնելու ընդհանուր նպատակին: Սա հանգեցրել է AI նվագախմբի անհրաժեշտությանը, որը ներառում է այնպիսի համակարգերի նախագծում, որոնք կարող են արդյունավետորեն կառավարել և համակարգել բազմաթիվ AI գործակալների միջև փոխազդեցությունները:

LangChain. AI գործակալների կառուցման շրջանակ

LangChain-ը Python-ի շրջանակ է՝ AI գործակալներ ստեղծելու համար, որոնք կարող են փոխազդել միմյանց և արտաքին համակարգերի հետ: Այն ապահովում է մի շարք գործիքներ և գրադարաններ, որոնք ծրագրավորողներին հնարավորություն են տալիս ստեղծել այնպիսի գործակալներ, որոնք կարող են տրամաբանել, սովորել և հարմարվել փոփոխվող միջավայրերին: LangChain-ը կառուցված է Rust ծրագրավորման լեզվի վրա և ապահովում է բարձր մակարդակի API՝ AI գործակալներ ստեղծելու համար:

DSPy. A Framework for Orchestration

DSPy-ը Python-ի շրջանակ է՝ բաշխված համակարգեր ստեղծելու համար, որոնք կարող են կազմակերպել բազմաթիվ AI գործակալներ: Այն ապահովում է մի շարք գործիքներ և գրադարաններ, որոնք ծրագրավորողներին հնարավորություն են տալիս նախագծել և տեղակայել մասշտաբային և ճկուն համակարգեր, որոնք կարող են կառավարել բազմաթիվ գործակալների միջև բարդ փոխազդեցությունները: DSPy-ը կառուցված է Apache Kafka հաղորդագրությունների համակարգի վերևում և ապահովում է բարձր մակարդակի API բաշխված համակարգեր կառուցելու համար:

** AI գործակալների ներդրում LangChain-ի և DSPy-ի հետ**

AI գործակալները LangChain-ի և DSPy-ի միջոցով իրականացնելու համար մենք պետք է հետևենք հետևյալ քայլերին.

Սահմանել Agent Architecture. Սահմանել AI գործակալի ճարտարապետությունը, ներառյալ մուտքերը, ելքերը և այլ գործակալների հետ փոխազդեցությունները:
Իրականացնել Գործակալի տրամաբանությունը. Իրականացնել AI գործակալի տրամաբանությունը՝ օգտագործելով LangChain-ը, ներառյալ հիմնավորումը, սովորելը և հարմարվողականության մեխանիզմները:
Կարգավորել Գործակալների փոխազդեցությունները. Օգտագործեք DSPy՝ AI բազմաթիվ գործակալների միջև փոխազդեցությունները կազմակերպելու համար, ներառյալ հաղորդակցման արձանագրությունները և տվյալների փոխանակման մեխանիզմները:
Տեղակայեք համակարգը. տեղակայեք համակարգը՝ օգտագործելով ամպային հարթակ կամ կոնտեյներացման շրջանակ, ինչպիսին է Docker-ը:

Կոդի օրինակ. AI պարզ գործակալի ներդրում LangChain-ի հետ

Ահա մի պարզ կոդի օրինակ, որը ցույց է տալիս, թե ինչպես իրականացնել AI գործակալ՝ օգտագործելով LangChain. «Պիթոն». ներմուծման լանգշղթա langchain.chains-ից ներմուծել LLMCchain

agent = langchain.Agent( input_schema={"տեքստ"՝ str}, output_schema={"տեքստ"՝ str}, շղթա=LLMC շղթա( մոդել = "davinci:instructix", max_length=2048, ջերմաստիճանը=0.7, ), )

Իրականացրեք գործակալի տրամաբանությունը

def agent_logic (input_text): output_text = agent.run (input_text) վերադարձնել output_text

Փորձարկեք գործակալին

input_text = «Ո՞րն է կյանքի իմաստը»: output_text = agent_logic (մուտքագրման_տեքստ) տպել (ելքային_տեքստ)

Այս կոդի օրինակը ցույց է տալիս, թե ինչպես կարելի է սահմանել AI գործակալ՝ օգտագործելով LangChain, ներառյալ մուտքային և ելքային սխեմաները և գործակալի տրամաբանությունը: Գործակալն իրականացվում է Large Language Model (LLM) շղթայի միջոցով, որը AI գործակալի տեսակ է, որը կարող է պատճառաբանել և ստեղծել տեքստ:

** Լավագույն 5-10 ամենաօգտագործվող հրամանները/հատվածները LangChain-ի և DSPy-ի համար**

Ահա 5-10 ամենաշատ օգտագործվող հրամանները/հատվածները LangChain-ի և DSPy-ի համար.

1. **langchain.Agent()**. Ստեղծում է AI գործակալի նոր օրինակ:
«Պիթոն».
agent = langchain.Agent(
    input_schema={"տեքստ"՝ str},
    output_schema={"տեքստ"՝ str},
    շղթա=LLMC շղթա(
        մոդել = "davinci:instructix",
        max_length=2048,
        ջերմաստիճանը=0.7,
    ),
)

agent.run(). Գործարկում է AI գործակալը տվյալ մուտքագրով: «Պիթոն». output_text = agent.run (input_text)

3. **DSPy.create_cluster()**. Ստեղծում է հանգույցների նոր կլաստեր բաշխված համակարգի համար:
«Պիթոն».
կլաստեր = DSPy.create_cluster(
    num_nodes=5,
    node_type = "աշխատող",
)

DSPy.create_agent(). Ստեղծում է նոր AI գործակալի օրինակ բաշխված համակարգի համար: «Պիթոն». գործակալ = DSPy.create_agent( կլաստեր = կլաստեր, agent_type="LLM", )

5. **DSPy.deploy_agent()**՝ տեղակայում է AI գործակալը բաշխված համակարգում:
«Պիթոն».
DSPy.deploy_agent(
    գործակալ=գործակալ,
    կլաստեր = կլաստեր,
)

DSPy.get_agent_status()՝ առբերում է AI գործակալի կարգավիճակը: «Պիթոն». կարգավիճակ = DSPy.get_agent_status( գործակալ=գործակալ, կլաստեր = կլաստեր, )

7. **DSpy.update_agent()**. Թարմացնում է AI գործակալը նոր տվյալներով կամ պարամետրերով:
«Պիթոն».
DSPy.update_agent(
    գործակալ=գործակալ,
    կլաստեր = կլաստեր,
    new_data={"text": "new input text"},
)

DSPy.delete_agent(). ջնջում է AI գործակալը բաշխված համակարգից: «Պիթոն». DSPy.delete_agent( գործակալ=գործակալ, կլաստեր = կլաստեր, )

9. **DSPy.create_chain()**. Ստեղծում է AI գործակալների նոր շղթա բաշխված համակարգի համար:
«Պիթոն».
շղթա = DSPy.create_chain(
    agents=[գործակալ1, գործակալ2, գործակալ3],
)

DSPy.deploy_chain(). տեղակայում է AI գործակալների շղթան բաշխված համակարգում: «Պիթոն». DSPy.deploy_chain( շղթա = շղթա, կլաստեր = կլաստեր, )

**Վիզուալիզացիա**

Ահա LangChain-ի և DSPy ճարտարապետության վիզուալիզացիան՝ օգտագործելով Chart.js.
```ջսոն
{
  "type": "pieChart",
  "տվյալներ": {
    «պիտակներ»: [«LangChain», «DSPy»],
    «տվյալների հավաքածուներ»:
      {
        «պիտակ»: «AI գործակալներ»,
        «տվյալներ»: [50, 50],
        "backgroundColor": ["#4CAF50", "#FF9800"]
      }
    ]
  },
  «Ընտրանքներ»: {
    «վերնագիր»: {
      «ցուցադրում»՝ ճշմարիտ,
      "text": "LangChain and DSPy Architecture"
    },
    "լեգենդ": {
      «ցուցադրում»՝ ճշմարիտ
    }
  }
}

Այս վիզուալիզացիան ցույց է տալիս AI գործակալների բաշխումը LangChain-ի և DSPy-ի միջև, ընդ որում գործակալների 50%-ն աշխատում է LangChain-ով, իսկ 50%-ը՝ DSPy-ով:

Եզրակացություն

LangChain-ը և DSPy-ը հզոր շրջանակ են ապահովում AI գործակալների կառուցման և կազմակերպման համար՝ հնարավորություն տալով ծրագրավորողներին նախագծել մասշտաբային և ճկուն համակարգեր, որոնք կարող են արդյունավետորեն կառավարել բազմաթիվ գործակալների միջև բարդ փոխազդեցությունները: Հետևելով այս հոդվածում նկարագրված քայլերին՝ ծրագրավորողները կարող են կիրառել AI գործակալներ՝ օգտագործելով LangChain և DSPy, և դրանք տեղակայել բաշխված համակարգում՝ օգտագործելով DSPy: Տրամադրված կոդի օրինակներն ու վիզուալիզացիան ցույց են տալիս LangChain-ի և DSPy-ի հնարավորությունները, իսկ ամենաշատ օգտագործվող 5-10 հրամանները/հատվածները արագ հղում են ապահովում մշակողների համար:

AI գործակալների կազմակերպում LangChain-ի և DSPy-ի հետ՝ ընդլայնված ծրագրային ճարտարապետության համար

Իրականացրեք գործակալի տրամաբանությունը

Փորձարկեք գործակալին

¿Tienes preguntas?