வேலை செய்யும் AI ஏஜென்ட் உருவாக்கவும்: ஒரு நடைமுறை சொற்களஞ்சியம்

AI ஏஜென்ட் என்பது ஒரு இலக்கை எடுத்து, செயல்களின் வரிசையை முடிவு செய்து, அந்த செயல்களை கருவிகளைப் பயன்படுத்தி இலக்கு அடையும் வரை அல்லது கைவிடும் வரை செயல்படுத்தும் ஒரு நிரல். இது சாட்பாட்டிலிருந்து வேறுபட்டது, இது செய்திகளுக்கு பதிலளிக்கிறது. ஒரு ஏஜென்ட் திட்டமிடுகிறது, செயல்பாடுகளை அழைக்கிறது, முடிவுகளை சரிபார்க்கிறது, மற்றும் சரிசெய்கிறது. நீங்கள் ChatGPT ஐ ப்ரவுசரின் மூலம் மட்டுமே பயன்படுத்தியிருந்தால், உங்கள் முதல் ஏஜென்ட்டை உருவாக்குவது என்பது மாதிரி உரை ஜெனারேட்டர் நிறுத்தி பெரிய அமைப்புக்கான ஒரு கூறு ஆகிறது.

முக்கிய வளையம்

பிற மாதிரிகள் எவ்வாறு விளம்பரப்படுகின்றன என்பது பொருட்டல்ல, ஒவ்வொரு ஏஜென்டும் একே வளையத்தின் சில பதிப்பை चलाயिত செய்கிறது: பகுதி, சிந்திக்கவும், செயல்படுத்தவும், மீண்டும் செய்யவும். குறிப்பாக:

1. ஏஜென்ட் ஒரு பணியை பெறுகிறது ("அடுத்த மாதம் Lisbon க்கு மலிவான விமानம் கண்டுபிடிக்கவும் மற்றும் ஒரு மின்னஞ்சல் சுருக்கம் உருவாக்கவும்").
2. இது LLM ஐ பணி மற்றும் கிடைக்கக்கூடிய கருவிகளின் விளக்கம் உடன் அழைக்கிறது.
3. மாதிரி இறுதி பதில் அல்லது search_flights(destination="Lisbon", month="2025-06") போன்ற கருவி அழைப்பை திருப்பி அனுப்புகிறது.
4. உங்கள் குறியீடு அந்த செயல்பாட்டைச் செயல்படுத்துகிறது, ஒரு உண்மையான முடிவைப் பெறுகிறது, மற்றும் அதை மாதிரির சூழ்நிலையில் திருப்பி உணவளிக்கிறது.
5. மாதிரி அடுத்து என்ன செய்வது என்பதை முடிவு செய்கிறது: மற்றொரு கருவியை அழைக்கவும், தெளிவுபடுத்தக் கேளவும், அல்லது முடிக்கவும்.

இந்த வடிவம் பெரும்பாலும் ReAct வளையம் (காரணம் மற்றும் செயல்) என அழைக்கப்படுகிறது, மேலும் இது LangChain இன் ஏஜென்ட் executor, LlamaIndex ஏஜென்ட, மற்றும் OpenAI இன் செயல்பாடு அழைப்பு API போன்ற கட்டமைப்புகளின் முதுகுத்தண்டு. நீங்கள் முழு விஷயத்தை Python இல் 100 வரிக்கும் குறைவாக LLM API மற்றும் while வளையத்துடன் தனியாக செயல்படுத்தலாம் — கட்டமைப்புகள் வசதியை சேர்க்கின்றன, மந்திரங்களை அல்ல.

கருவிகள் இதை ஒரு ஏஜென்ட்டாக மாற்றுகின்றன

கருவிகள் இல்லாமல் ஒரு மாதிரி மட்டும் பேசலாம். இதற்கு செயல்பாடுகளை கொடுங்கள் மற்றும் இது செயல்பட முடியும். கருவிகள் பொதுவாக ஒரு schema உடன் மூடப்பட்ட Python செயல்பாடுகள் ஆகும் அவற்றின் பெயர், parameters, மற்றும் நோக்கம் விளக்குகிறது, அதனால் மாதிரி எப்போது மற்றும் எவ்வாறு அவற்றை அழைப்பது என்று தெரியும். உதாரணம்:

def get_weather(city: str) -> str:
    """Return current weather for a given city."""
    resp = requests.get(f"https://api.weather.example/v1/{city}")
    return resp.json()["summary"]

OpenAI இன் செயல்பாடு அழைப்பு உடன், நீங்கள் இந்த செயல்பாடுடன் JSON schema ஐ அனுப்புகிறீர்கள், மாதிரி freeform உரல் பதிலாக {"name": "get_weather", "arguments": {"city": "Lisbon"}} போன்ற ஒரு structured அழைப்பு வெளியிடுகிறது. உங்கள் குறியீடு அதை பாரசவளிக்கிறது, உண்மையான செயல்பாட்டை செயல்படுத்துகிறது, மற்றும் முடிவை conversation இல் ஒரு புதிய செய்தியாக திருப்பி அனுப்புகிறது. மாதிரி பதிலளிக்க போதுமான தகவல் வரை மீண்டும் செய்யவும்.

நினைவாற்றல் மற்றும் state

ஒரு single API அழைப்புக்கு அதன் context window க்கு அப்பால் நினைவாற்றல் இல்லை. ஏஜென்டுகளுக்கு explicit state தேவை: messages இன் ஒரு চলমান பட்டியல் (conversation history), மற்றும் பெரும்பாலும் நீண்ட கால facts க்கான ஒரு தனி store. சுருக்க பணிகளுக்கு, conversation ஐ பிரதிநிதித்வம் செய்யும் dicts இன் Python பட்டியல் போதுமானது. sessions முழுவதும் விஷயங்களை நினைவில் கொள்ள வேண்டிய ஏஜென்டுகளுக்கு, embeddings மூலம் பொருத்தமான கடந்தகাल தகவல்களை store மற்றும் retrieve செய்ய ஒரு vector database (Chroma, Pinecone, Qdrant) க்கு செல்லலாம்.

இந்த initial கட்டத்தில் over-engineer செய்யாதீர்கள். ஆச்சரியகரமாக, பல "agent" projects LLM பலவீனமாக இருப்பதால் அல்ல மாறாக state management சவாக்கமாக இருப்பதாலேயே தோல்வியடைகின்றன: duplicate messages, unbounded context growth, அல்லது எந்த tool call எந்த result க்கு சொந்தம் என்பதை잃きऱा செய்கிறது.

ஒரு குறைந்தபட்ச வேலை செய்யும் உதாரணம்

கட்டமைப்பு இல்லாமல் OpenAI இன் API ஐ பயன்படுத்தும் ஒரு முறிந்த agent இன் வடிவம்:

messages = [{"role": "user", "content": "What's the weather in Lisbon?"}]

while True:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        tools=[weather_tool_schema],
    )
    msg = response.choices[0].message
    if msg.tool_calls:
        for call in msg.tool_calls:
            result = get_weather(**json.loads(call.function.arguments))
            messages.append(msg)
            messages.append({
                "role": "tool",
                "tool_call_id": call.id,
                "content": result,
            })
    else:
        print(msg.content)
        break

அது ஒரு உண்மையான, செயல்பாட்டாகும் agent. மற்ற எல்லாக்கூ — planning strategies, multi-agent coordination, retrieval pipelines — இந்த வளையத்தை அடிப்படையாக கொண்டு உருவாக்குகிறது.

அது எங்கே உடைகிறது

ஏஜென்டுகள் முன்னறிவிக்கக்கூடிய வழிகளில் தோல்வியடைகின்றன: infinite tool-call வளையங்கள் மாதிரி அது வெற்றி அடைந்ததாக சொல்ல முடியாதபோது, hallucinated செயல்பாடு arguments, மற்றும் महंगे கருவிகளை மீண்டும் அழைப்பதிலிருந்து runaway costs. வளையங்களிலிருந்து guards உடன் ஒரு hard iteration cap (say, 10 steps) மற்றும் development இல் ஒவ்வொரு tool call ஐ log செய்யவும். உண்மையான system ஐ தொடும் எந்த விஷயத்தை execute செய்வதற்கு முன்பு arguments validate செய்யவும் — emails அனுப்பவோ அல்லது shell commands ஐ চালாயிடவோ கூடிய ஒரு agent க்கு நீங்கள் user-facing குறியீடுக்கு பயன்படுத்தும் அதே input sanitation தேவை, LLM உண்மையில் அந்த input உருவாக்கும் ஒரு untrusted user ஆக இருப்பதால்.

அடுத்ত செல்ல வேண்டிய இடம்

வளையம் வேலை செய்யும் முன்பு, interesting problems தொடங்கும்: single-agent மற்றும் multi-agent designs மধ்যে தேர்ந்தெடுப்பு, எவ்வளவு autonomy வழங்க வேண்டும் என்பதை முடிவு செய்தல், மற்றும் ஏஜென்டுகளை நம்பகமாக testing செய்தல் அவற்றின் output deterministic அல்ல. Korra Studio இன் AI மற்றும் Python tracks retrieval-augmented generation, prompt design, மற்றும் tool-calling patterns ஐ மேலும் ஆழத்தில் உள்ளடக்குகின்றன நீங்கள் இங்கிருந்து தொடர்ந்து உருவாக்க விரும்பினால்.