Gabatarwa

An sami karuwa mai yawa a aikace-aikace ta amfani da wakilai na coding AI. Tare da haɓaka ingancin LLMs da rage farashin ƙima, ana samun sauƙi kawai don gina ma'aikatan AI. A saman wannan, yanayin yanayin kayan aiki yana ci gaba da sauri, yana sauƙaƙa don gina hadaddun wakilai na coding AI. Tsarin Langchain ya kasance jagora akan wannan gaba. Yana da duk kayan aikin da ake buƙata da dabaru don ƙirƙirar aikace-aikacen AI masu shirye-shiryen samarwa.

Amma ya zuwa yanzu, an rasa a cikin abu ɗaya. Kuma wannan shine haɗin gwiwar wakilai da yawa tare da cyclicity. Wannan yana da mahimmanci don magance matsaloli masu rikitarwa, inda za'a iya raba matsalar kuma a ba da su ga wakilai na musamman. Wannan shine inda LangGraph ya shigo cikin hoton, wani ɓangare na tsarin Langchain wanda aka tsara don ɗaukar haɗin gwiwar manyan 'yan wasan kwaikwayo da yawa tsakanin wakilan AI coding. Bugu da ari, a cikin wannan labarin, zamu tattauna LangGraph da ainihin tubalan ginin sa yayin da muke gina wakili tare da shi.

makasudin

• Fahimci menene LangGraph.
• Bincika abubuwan da suka dace na LangGraph don gina Agents na gari.
• Bincika Tare AI don samun dama ga samfuran shiga buɗe kamar DeepSeekCoder.
• Gina wakilin AI ta amfani da LangGraph don rubuta gwajin naúrar.

An buga wannan labarin a matsayin wani ɓangare na Bayanan Kimiyya Blogathon.

Menene LangGraph?

LangGraph tsawaita ne na yanayin yanayin LangChain. Duk da yake LangChain yana ba da damar gina wakilai na AI waɗanda za su iya amfani da kayan aiki da yawa don aiwatar da ayyuka, ba zai iya daidaita sarƙoƙi ko ƴan wasan kwaikwayo da yawa a cikin matakan ba. Wannan hali ne mai mahimmanci don ƙirƙirar wakilai waɗanda ke aiwatar da ayyuka masu rikitarwa. An haifi LangGraph yana kiyaye waɗannan abubuwan a zuciya. Yana kula da aikin Agent azaman tsarin zane mai zagaye, inda kowane kumburi yake wakiltar aiki ko abu na Langchain Runnable, kuma gefuna sune haɗin kai tsakanin nodes. 

Manyan abubuwan LangGraph sun haɗa da 

• nodes: Duk wani aiki ko Langchain Runnable abu kamar kayan aiki.
• Ƙarshe: Yana bayyana alkibla tsakanin nodes.
• Zane-zane na Jiha: Nau'in farko na jadawali. An ƙera shi don sarrafawa da sabunta abubuwa na jihohi yayin da yake aiwatar da bayanai ta cikin nodes ɗinsa.

LangGraph yana yin amfani da wannan don sauƙaƙe aiwatar da kiran LLM na keke-da-keke tare da dagewar jiha, wanda ke da mahimmanci ga ɗabi'a. Gine-gine yana samun wahayi daga Pregel da kuma Apache katako. 

A cikin wannan labarin, za mu gina Wakili don rubuta gwajin rukunin Pytest don ajin Python tare da hanyoyi. Kuma wannan shine tsarin aiki.

Za mu tattauna ra'ayoyin daki-daki yayin da muke gina wakilin mu na AI don rubuta gwajin raka'a mai sauƙi. Don haka, bari mu je sashin coding.

Amma kafin nan, mu tsara yanayin ci gabanmu.

Shigar Dependencies

Abu na farko da farko. Kamar yadda yake tare da kowane aikin Python, ƙirƙirar yanayi mai kama da aiki kuma kunna shi.

python -m venv auto-unit-tests-writer
cd auto-unit-tests-writer
source bin/activate

Yanzu, shigar da abin dogara.

!pip install langgraph langchain langchain_openai colorama

Shigo da duk ɗakunan karatu da azuzuwan su.

from typing import TypedDict, List
import colorama
import os

from langchain_openai import ChatOpenAI
from langchain_core.messages import SystemMessage
from langchain_core.messages import HumanMessage
from langchain_core.runnables import RunnableConfig

from langgraph.graph import StateGraph, END
from langgraph.pregel import GraphRecursionError

Hakanan za mu so ƙirƙirar kundayen adireshi da fayiloli don shari'o'in gwaji. Kuna iya ƙirƙirar fayiloli da hannu ko amfani da Python don hakan.

# Define the paths.
search_path = os.path.join(os.getcwd(), "app")
code_file = os.path.join(search_path, "src/crud.py")
test_file = os.path.join(search_path, "test/test_crud.py")

# Create the folders and files if necessary.
if not os.path.exists(search_path):
    os.mkdir(search_path)
    os.mkdir(os.path.join(search_path, "src"))
    os.mkdir(os.path.join(search_path, "test"))

Yanzu, sabunta fayil ɗin crud.py tare da lamba don ƙa'idar CRUD na ƙwaƙwalwar ajiya. Za mu yi amfani da wannan lambar don rubuta gwajin raka'a. Kuna iya amfani da shirin ku na Python don wannan. Za mu ƙara shirin da ke ƙasa zuwa fayil ɗin code.py ɗin mu.

#crud.py
code = """class Item:
    def __init__(self, id, name, description=None):
        self.id = id
        self.name = name
        self.description = description

    def __repr__(self):
        return f"Item(id={self.id}, name={self.name}, description={self.description})"

class CRUDApp:
    def __init__(self):
        self.items = []

    def create_item(self, id, name, description=None):
        item = Item(id, name, description)
        self.items.append(item)
        return item

    def read_item(self, id):
        for item in self.items:
            if item.id == id:
                return item
        return None

    def update_item(self, id, name=None, description=None):
        for item in self.items:
            if item.id == id:
                if name:
                    item.name = name
                if description:
                    item.description = description
                return item
        return None

    def delete_item(self, id):
        for index, item in enumerate(self.items):
            if item.id == id:
                return self.items.pop(index)
        return None

    def list_items(self):
        return self.items"""
        
with open(code_file, 'w') as f:
  f.write(code)

Saita LLM

Yanzu, za mu ƙayyade LLM da za mu yi amfani da shi a cikin wannan aikin. Wani samfurin da za a yi amfani da shi a nan ya dogara da ayyuka da wadatar albarkatun. Kuna iya amfani da samfura masu ƙarfi, masu ƙarfi kamar GPT-4, Gemini Ultra, ko GPT-3.5. Hakanan, zaku iya amfani da samfuran buɗewa kamar Mixtral da Llama-2. A wannan yanayin, kamar yadda ya shafi rubuta lambobin, za mu iya amfani da ingantaccen tsarin coding kamar DeepSeekCoder-33B ko Llama-2 coder. Yanzu, akwai dandamali da yawa don ƙaddamar da LLM, kamar Anayscale, Abacus, da Tare. Za mu yi amfani da Tare AI don fahimtar DeepSeekCoder. Don haka, sami wani API key daga Tare kafin muci gaba. 

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(base_url="https://api.together.xyz/v1",
    api_key="your-key",
    model="deepseek-ai/deepseek-coder-33b-instruct")

Kamar yadda API ɗin ya dace da OpenAI SDK, za mu iya amfani da Langchain's OpenAI SDK don sadarwa tare da samfuran da aka shirya tare ta hanyar canza ma'aunin base_url zuwa. "https://api.together.xyz/v1". A cikin api_key, wuce maɓallin API ɗin ku tare, kuma a madadin samfura, wuce da sunan samfuri akwai akan Tare.

Ƙayyade Jihar Wakili

Wannan shine ɗayan mahimman sassan LangGraph. Anan, za mu ayyana wani AgentState, wanda ke da alhakin lura da jihohin Agents a duk lokacin aiwatar da aiwatarwa. Wannan da farko ajin TypedDict ne tare da ƙungiyoyi waɗanda ke kula da yanayin Agents. Bari mu ayyana AgentState

class AgentState(TypedDict):
    class_source: str
    class_methods: List[str]
    tests_source: str

A cikin aji AgentState na sama, class_source yana adana ajin Python na asali, hanyoyin class_na adana hanyoyin ajin, da kuma tests_source don lambobin gwajin naúrar. Mun ayyana waɗannan azaman AgentState don amfani da su a cikin matakan aiwatarwa. 

Yanzu, ayyana ginshiƙi tare da AgentState.

# Create the graph.
workflow = StateGraph(AgentState)

Kamar yadda aka ambata a baya, wannan jadawali ne, kuma yanzu mun ƙara abin jihar mu.

Bayyana Nodes

Yanzu da muka ayyana AgentState, muna buƙatar ƙara nodes. Don haka, menene ainihin nodes? A cikin LangGraph, nodes ayyuka ne ko kowane abu mai gudana, kamar kayan aikin Langchain, waɗanda ke yin aiki ɗaya. A cikin yanayinmu, zamu iya ayyana nodes da yawa, kamar aikin nemo hanyoyin aji, aiki don ƙididdigewa da sabunta gwaje-gwajen naúrar zuwa bayyana abubuwa, da aikin rubuta shi zuwa fayil ɗin gwaji.

Muna kuma buƙatar hanyar cire lambobi daga saƙon LLM. Ga yadda.

def extract_code_from_message(message):
    lines = message.split("n")
    code = ""
    in_code = False
    for line in lines:
        if "```" in line:
            in_code = not in_code
        elif in_code:
            code += line + "n"
    return code

snippet code anan yana ɗaukan lambobin su kasance cikin ƙa'idodin sau uku.

Yanzu, bari mu ayyana nodes.

import_prompt_template = """Here is a path of a file with code: {code_file}.
Here is the path of a file with tests: {test_file}.
Write a proper import statement for the class in the file.
"""
# Discover the class and its methods.
def discover_function(state: AgentState):
    assert os.path.exists(code_file)
    with open(code_file, "r") as f:
        source = f.read()
    state["class_source"] = source

    # Get the methods.
    methods = []
    for line in source.split("n"):
        if "def " in line:
            methods.append(line.split("def ")[1].split("(")[0])
    state["class_methods"] = methods

    # Generate the import statement and start the code.
    import_prompt = import_prompt_template.format(
        code_file=code_file,
        test_file=test_file
    )
    message = llm.invoke([HumanMessage(content=import_prompt)]).content
    code = extract_code_from_message(message)
    state["tests_source"] = code + "nn"

    return state


# Add a node to for discovery.
workflow.add_node(
    "discover",
    discover_function
)

A cikin snippet ɗin lambar da ke sama, mun ayyana aiki don gano lambobin. Yana fitar da lambobin daga AgentState class_source kashi, rarraba ajin zuwa hanyoyin daidaikun mutane, kuma ya tura shi zuwa ga LLM tare da faɗakarwa. Ana adana abubuwan fitarwa a cikin AgentState's tests_source kashi. Mu kawai muke sanya shi rubuta bayanan shigo da kaya don shari'o'in gwajin naúrar.

Mun kuma ƙara kumburin farko zuwa abu na StateGraph.

Yanzu, zuwa kumburi na gaba. 

Hakanan, zamu iya saita wasu samfuran gaggawa waɗanda zamu buƙaci anan. Waɗannan samfuran samfuri ne waɗanda zaku iya canzawa gwargwadon buƙatun ku.

# System message template.

system_message_template = """You are a smart developer. You can do this! You will write unit 
tests that have a high quality. Use pytest.

Reply with the source code for the test only. 
Do not include the class in your response. I will add the imports myself.
If there is no test to write, reply with "# No test to write" and 
nothing more. Do not include the class in your response.

Example:

```
def test_function():
    ...
```

I will give you 200 EUR if you adhere to the instructions and write a high quality test. 
Do not write test classes, only methods.
"""

# Write the tests template.
write_test_template = """Here is a class:
'''
{class_source}
'''

Implement a test for the method "{class_method}".
"""

Yanzu, ayyana kumburi.

# This method will write a test.
def write_tests_function(state: AgentState):

    # Get the next method to write a test for.
    class_method = state["class_methods"].pop(0)
    print(f"Writing test for {class_method}.")

    # Get the source code.
    class_source = state["class_source"]

    # Create the prompt.
    write_test_prompt = write_test_template.format(
        class_source=class_source,
        class_method=class_method
    )
    print(colorama.Fore.CYAN + write_test_prompt + colorama.Style.RESET_ALL)

    # Get the test source code.
    system_message = SystemMessage(system_message_template)
    human_message = HumanMessage(write_test_prompt)
    test_source = llm.invoke([system_message, human_message]).content
    test_source = extract_code_from_message(test_source)
    print(colorama.Fore.GREEN + test_source + colorama.Style.RESET_ALL)
    state["tests_source"] += test_source + "nn"

    return state

# Add the node.
workflow.add_node(
    "write_tests",
    write_tests_function
)

Anan, za mu sanya LLM ya rubuta shari'o'in gwaji don kowace hanya, sabunta su zuwa abubuwan gwaji_source AgentState, sannan mu ƙara su zuwa abubuwan StateGraph mai gudana.

Ƙarshe

Yanzu da muke da nodes guda biyu, za mu ayyana gefuna a tsakanin su don tantance alkiblar kisa a tsakanin su. LangGraph yana samar da farko nau'ikan gefuna biyu.

• Gefen Sharadi: Gudun aiwatar da aiwatarwa ya dogara da martanin wakilai. Wannan yana da mahimmanci don ƙara cyclicity zuwa ayyukan aiki. Wakilin zai iya yanke shawarar kodin da zai matsa gaba bisa wasu sharudda. Ko don komawa kumburin baya, maimaita na yanzu, ko matsawa zuwa kumburi na gaba.
• Edge na al'ada: Wannan lamari ne na al'ada, inda koyaushe ana kiran kumburi bayan kiran waɗanda suka gabata.

Ba ma buƙatar yanayi don haɗa ganowa da rubuta_test, don haka za mu yi amfani da gefen al'ada. Har ila yau, ayyana wurin shigarwa wanda ke ƙayyade inda ya kamata a fara aiwatar da kisa.

# Define the entry point. This is where the flow will start.
workflow.set_entry_point("discover")

# Always go from discover to write_tests.
workflow.add_edge("discover", "write_tests")

Kisa yana farawa tare da gano hanyoyin kuma yana zuwa aikin rubuce-rubucen gwaje-gwaje. Muna buƙatar wani kumburi don rubuta lambobin gwajin naúrar zuwa fayil ɗin gwaji.

# Write the file.
def write_file(state: AgentState):
    with open(test_file, "w") as f:
        f.write(state["tests_source"])
    return state

# Add a node to write the file.
workflow.add_node(
    "write_file",
    write_file)

Kamar yadda wannan shine kullin mu na ƙarshe, za mu ayyana gefe tsakanin write_tests da write_file. Ta haka ne za mu iya yin hakan.

# Find out if we are done.
def should_continue(state: AgentState):
    if len(state["class_methods"]) == 0:
        return "end"
    else:
        return "continue"

# Add the conditional edge.
workflow.add_conditional_edges(
    "write_tests",
    should_continue,
    {
        "continue": "write_tests",
        "end": "write_file"
    }
)

Ayyukan add_conditional_edge yana ɗaukar aikin rubuta_tests, aikin yakamata_ci gaba da yanke shawarar matakin da za'a ɗauka dangane da shigarwar class_methods, da taswira tare da kirtani azaman maɓalli da sauran ayyuka azaman ƙima.

Gefen yana farawa a write_tests kuma, dangane da fitarwa na should_continue, yana aiwatar da ɗayan zaɓuɓɓukan da ke cikin taswirar. Misali, idan jihar[“class_ths”] ba ta da komai, ba mu rubuta gwaje-gwaje ga duk hanyoyin ba; muna maimaita aikin rubuta_tests, kuma idan mun gama rubuta gwaje-gwajen, ana aiwatar da write_file.

Lokacin da gwaje-gwaje na duk hanyoyin da aka kimanta daga LLM, an rubuta gwajin zuwa fayil ɗin gwaji.

Yanzu, ƙara gefen ƙarshe zuwa abu mai gudana don rufewa.

# Always go from write_file to end.
workflow.add_edge("write_file", END)

Ci gaba da Ayyukan Aiki

Abu na ƙarshe da ya rage shi ne tattara ayyukan aiki da gudanar da shi.

# Create the app and run it
app = workflow.compile()
inputs = {}
config = RunnableConfig(recursion_limit=100)
try:
    result = app.invoke(inputs, config)
    print(result)
except GraphRecursionError:
    print("Graph recursion limit reached.")

Wannan zai kira app. Matsakaicin maimaitawa shine adadin lokutan da LLM za'a iya tantancewa don aikin da aka bayar. Gudun aikin yana tsayawa lokacin da aka wuce iyaka.

Kuna iya ganin rajistan ayyukan akan tashar tashar ko a cikin littafin rubutu. Wannan shine log ɗin aiwatarwa don ƙa'idar CRUD mai sauƙi.

Yawancin ɗagawa mai nauyi za a yi ta ƙirar da ke ƙasa, wannan aikace-aikacen demo ne tare da ƙirar coder Deepseek, don ingantaccen aiki zaku iya amfani da GPT-4 ko Claude Opus, haiku, da sauransu.

 Hakanan zaka iya amfani da kayan aikin Langchain don hawan yanar gizo, nazarin farashin hannun jari, da sauransu.

LangChain vs LangGraph

Yanzu, tambayar ita ce lokacin amfani da LangChain vs LangGraph.

Idan makasudin shine ƙirƙirar tsarin wakilai da yawa tare da daidaitawa a tsakanin su, LangGraph shine hanyar da za a bi. Koyaya, idan kuna son ƙirƙirar DAGs ko sarƙoƙi don kammala ayyuka, Harshen Maganar LangChain ya fi dacewa.

Me yasa ake amfani da LangGraph?

LangGraph tsari ne mai ƙarfi wanda zai iya inganta yawancin hanyoyin da ake da su. 

• Inganta bututun RAG: LangGraph na iya ƙara RAG tare da tsarin zane mai zagaye. Za mu iya gabatar da madauki na amsa don kimanta ingancin abin da aka dawo da shi kuma, idan an buƙata, za mu iya inganta tambaya kuma a maimaita aikin.
• Multi-Agent Workflows: An tsara LangGraph don tallafawa ayyukan aiki da yawa. Wannan yana da mahimmanci don magance hadaddun ayyuka zuwa ƙananan ayyuka. Wakilai daban-daban tare da jihar da aka raba da LLM daban-daban da kayan aikin zasu iya haɗa kai don magance ɗawainiya ɗaya.
• Mutum-in-da-madauki: LangGraph yana da ginanniyar goyan baya ga aikin ɗan adam-in-da-madauki. Wannan yana nufin mutum zai iya sake duba jahohin kafin ya koma kulli na gaba.
• Wakilin Tsare-tsare: LangGraph ya dace sosai don gina wakilai na tsarawa, inda mai tsara shirin LLM ya tsara kuma ya rushe buƙatun mai amfani, mai zartarwa yana kiran kayan aiki da ayyuka, kuma LLM yana haɗa amsoshi dangane da abubuwan da suka gabata.
• Multi-modal Agents: LangGraph na iya gina jami'ai masu yawa, kamar mai kunna hangen nesa yanar gizo navigators.

Abubuwan Amfani na Gaskiya

Akwai filaye da yawa inda hadaddun wakilai na coding AI zasu iya taimakawa. 

1. Wakilin Keɓaɓɓens: Ka yi tunanin samun mataimaki naka kamar Jarvis akan na'urorin lantarki naka, a shirye don taimakawa da ayyuka a umarninka, ko ta hanyar rubutu, murya, ko ma alama. Wannan shine ɗayan mafi kyawun amfani da wakilan AI!
2. AI Malamai: Chatbots suna da kyau, amma suna da iyaka. Ma'aikatan AI sanye take da kayan aikin da suka dace zasu iya wuce tattaunawa ta asali. Masu koyarwa na Virtual AI waɗanda za su iya daidaita hanyoyin koyarwarsu bisa ga ra'ayin mai amfani na iya canza wasa.
3. UX software: Ana iya inganta ƙwarewar mai amfani da software tare da wakilan AI. Maimakon kewaya aikace-aikace da hannu, wakilai na iya cika ayyuka tare da umarnin murya ko karimci.
4. Kwamfuta na sararin samaniya: Kamar yadda fasahar AR/VR ke girma cikin shahara, buƙatun wakilan AI za su girma. Wakilai na iya aiwatar da bayanan da ke kewaye da kuma aiwatar da ayyuka bisa buƙata. Wannan na iya zama ɗaya daga cikin mafi kyawun maganganun amfani da wakilan AI ba da daɗewa ba.
5. LLM OS: AI-tsarin aiki na farko inda wakilai su ne 'yan ƙasa na farko. Wakilai za su ɗauki nauyin yin ayyuka na yau da kullun zuwa hadaddun ayyuka.

Kammalawa

LangGraph ingantaccen tsari ne don gina tsarin wakili na mai wasan kwaikwayo da yawa. Ya cika rata a cikin ainihin tsarin LangChain. Kamar yadda yake fadada LangChain, za mu iya amfana daga duk kyawawan abubuwa na yanayin yanayin LangChain. Yayin da inganci da iyawar LLMs ke girma, zai zama da sauƙi don ƙirƙirar tsarin wakilai don sarrafa hadaddun ayyukan aiki. Don haka, ga mahimman abubuwan da ake ɗauka daga labarin. 

Maɓallin Takeaways

• LangGraph shine tsawo na LangChain, wanda ke ba mu damar gina tsarin cyclic, stateful, multi-anctor agents.
• Yana aiwatar da tsarin jadawali tare da nodes da gefuna. Nodes ayyuka ne ko kayan aiki, kuma gefuna sune haɗin kai tsakanin nodes.
• Gefuna iri biyu ne: na sharadi da na al'ada. Gefuna na yanayi suna da yanayi yayin tafiya daga juna zuwa wani, wanda ke da mahimmanci don ƙara hawan keke zuwa aikin aiki.
• An fi son LangGraph don gina jami'an wasan kwaikwayo da yawa, yayin da LangChain ya fi kyau a ƙirƙirar sarƙoƙi ko tsarin tsarin acyclic.

Tambayoyin da

Kafofin watsa labaru da aka nuna a cikin wannan labarin ba mallakin Vidhya Analytics bane kuma ana amfani dashi bisa ga ra'ayin Mawallafin.

• Ƙunshin Ƙarfafa SEO & Rarraba PR. Samun Girma a Yau.
• PlatoData.Network Tsaye Generative Ai. Karfafa Kanka. Shiga Nan.
• PlatoAiStream. Web3 Mai hankali. Ilmi Ya Faru. Shiga Nan.
• PlatoESG. Carbon, CleanTech, Kuzari, Muhalli, Solar, Gudanar da Sharar gida. Shiga Nan.
• PlatoHealth. Biotech da Clinical Trials Intelligence. Shiga Nan.
• Source: https://www.analyticsvidhya.com/blog/2024/03/build-an-ai-coding-agent-with-langgraph-by-langchain/