aidoc.uz

2-qism · Agentlarni qurish·05-bob

Agentlarga harakat berish

Function calling protokoli ichidan: LLM funksiyani qanday tanlaydi, parallel chaqiruvlar, natijani qaytarish sikli. Semantic Kernel bilan semantik va tabiiy funksiyalarni birlashtirish.

Agent gapira oladi. Endi unga harakat beramiz — tashqi funksiyalarni chaqirish imkoniyati.

Bu bob function calling protokolini ichidan ko'rsatadi. Ko'p qo'llanmalar buni freymvork ichida yashiradi — biz esa nima bo'layotganini ko'ramiz, chunki buni tushunmasangiz, nosozlikni tuzata olmaysiz.

Function calling: asosiy tushuncha#

Bu — butun bobning eng muhim g'oyasi. Uni puxta bilib oling:

LLM funksiyani o'zi ishga tushirmaydi. U faqat "men shu funksiyani shu argumentlar bilan chaqirmoqchiman" deb aytadi. Chaqirishni siz qilasiz.

"Menga vaqt sayohati filmini tavsiya qil"
foydalanuvchi so'rovi + funksiya ta'riflari
LLM mos funksiyani ANIQLAYDI
«recommend» funksiyasi mos keladi
argumentlarni AJRATADI
{"topic": "vaqt sayohati filmi"}
funksiya nomi + argumentlarni qaytaradi
LEKIN o'zi bajarmaydi
LLM funksiya ta'rifini ko'rib, javobini funksiya chaqiruviga aylantiradi

Funksiyani e'lon qilish#

Funksiya ta'rifi — bu LLM'ga beriladigan "menyu". U qaysi funksiya borligini va qanday chaqirishni ko'rsatadi.

from openai import OpenAI
 
client = OpenAI()
 
 
def sora(user_message):
    javob = client.chat.completions.create(
        model="gpt-4-turbo",
        messages=[
            {"role": "system", "content": "Siz foydali yordamchisiz."},
            {"role": "user", "content": user_message},
        ],
        temperature=0.7,
        tools=[
            {
                "type": "function",
                "function": {
                    "name": "recommend",
                    "description": "Berilgan mavzu bo'yicha tavsiya beradi.",
                    "parameters": {
                        "type": "object",
                        "properties": {
                            "topic": {
                                "type": "string",
                                "description": "Tavsiya so'ralayotgan mavzu",
                            },
                            "rating": {
                                "type": "string",
                                "description": "Tavsiya sifati",
                                "enum": ["good", "bad", "terrible"],   # cheklangan qiymatlar
                            },
                        },
                        "required": ["topic"],
                    },
                },
            }
        ],
    )
    return javob

Nima qaytadi:

# "Vaqt sayohati filmini tavsiya qil"
Function(arguments='{"topic":"vaqt sayohati filmi"}', name='recommend')
 
# "Yaxshi vaqt sayohati filmini tavsiya qil"
Function(arguments='{"topic":"vaqt sayohati filmi","rating":"good"}', name='recommend')

Diqqat qiling: model argumentlarni matndan ajratib oldi. "Yaxshi" so'zini rating: good ga aylantirdi. Bu — function calling'ning kuchi.

To'liq sikl: funksiyani bajarish#

LLM funksiyani chaqirishni so'radi. Endi biz uni bajarib, natijani qaytaramiz.

1. Siz → LLM
so'rov + funksiya ta'riflari
2. LLM → siz
«recommend funksiyasini shu argumentlar bilan chaqir»
3. SIZ funksiyani bajarasiz
sizning kodingiz, model emas
4. Siz → LLM
funksiya natijasini qaytarasiz
5. LLM → siz
natijani tabiiy tilga aylantiradi
To'liq function calling sikli

Haqiqiy funksiya:

import json
 
 
def recommend(topic, rating="good"):
    """Bu — haqiqiy Python funksiyasi. Model uni chaqirishni so'raydi, biz bajaramiz."""
    if "vaqt sayohati" in topic.lower():
        return json.dumps({"topic": "vaqt sayohati", "tavsiya": "Orqaga kelajakka", "rating": rating})
    elif "retsept" in topic.lower():
        return json.dumps({"topic": "retsept", "tavsiya": "Osh", "rating": rating})
    elif "sovg'a" in topic.lower():
        return json.dumps({"topic": "sovg'a", "tavsiya": "Kitob", "rating": rating})
    else:
        return json.dumps({"topic": topic, "tavsiya": "noma'lum"})

To'liq sikl:

def suhbat(user_message):
    xabarlar = [
        {"role": "system", "content": "Siz foydali yordamchisiz."},
        {"role": "user", "content": user_message},
    ]
 
    # 1. Birinchi so'rov — funksiya ta'riflari bilan
    javob = client.chat.completions.create(
        model="gpt-4-turbo",
        messages=xabarlar,
        tools=TOOLS,
    )
 
    xabar = javob.choices[0].message
    tool_calls = xabar.tool_calls
 
    if not tool_calls:
        return xabar.content              # funksiya kerak emas, oddiy javob
 
    # 2. Assistant javobini tarixga qo'shamiz
    xabarlar.append(xabar)
 
    # 3. Har funksiyani bajaramiz
    mavjud = {"recommend": recommend}
 
    for tool_call in tool_calls:
        funksiya_nomi = tool_call.function.name
        argumentlar = json.loads(tool_call.function.arguments)   # JSON'ni tahlil qilamiz
 
        natija = mavjud[funksiya_nomi](**argumentlar)
 
        # 4. Natijani tarixga qo'shamiz — tool_call_id bilan
        xabarlar.append({
            "role": "tool",
            "tool_call_id": tool_call.id,     # QAYSI chaqiruvga tegishli
            "name": funksiya_nomi,
            "content": natija,
        })
 
    # 5. Ikkinchi so'rov — model natijani tabiiy tilga aylantiradi
    yakuniy = client.chat.completions.create(
        model="gpt-4-turbo",
        messages=xabarlar,
    )
    return yakuniy.choices[0].message.content

Parallel funksiya chaqiruvlari#

Model bir vaqtda bir necha funksiya chaqirishi mumkin:

user = """Menga quyidagilarni tavsiya qil:
1. Vaqt sayohati filmi
2. Retsept
3. Sovg'a"""

Model uchta recommend chaqiruvini qaytaradi — har biri boshqa argument bilan. Yuqoridagi kod for tool_call in tool_calls bilan buni allaqachon hal qiladi: har uchtasini bajaradi, hammasini tarixga qo'shadi.

Semantic Kernel#

Microsoft'ning Semantic Kernel (SK) — funksiyalarni boshqacha tashkil qiladi. Uning asosiy g'oyasi: ikki xil funksiyani birlashtirish.

1
Semantik funksiya
Bu — prompt shabloni. LLM bajaradi. Masalan: «{matn}ni xulosala». Tabiiy til bilan ishlaydi.
2
Tabiiy (native) funksiya
Bu — oddiy Python kod. Kompyuter bajaradi. Masalan: sana hisoblash, faylni o'qish, API chaqirish. Aniq va tez.

SK'ning kuchi — ikkalasini bir zanjirda birlashtirishda.

Semantik funksiya#

import semantic_kernel as sk
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
 
kernel = sk.Kernel()
kernel.add_service(OpenAIChatCompletion(service_id="chat", ai_model_id="gpt-4"))
 
# Semantik funksiya — bu prompt shabloni
xulosala_prompt = """Quyidagi matnni bitta jumlada xulosala:
 
{{$input}}
 
Xulosa:"""
 
xulosala = kernel.add_function(
    function_name="xulosala",
    plugin_name="matn",
    prompt=xulosala_prompt,
)
 
natija = await kernel.invoke(xulosala, input="uzun matn...")

{{$input}} — bu kontekst o'zgaruvchisi. SK uni haqiqiy qiymat bilan almashtiradi.

Tabiiy funksiya#

from semantic_kernel.functions import kernel_function
 
 
class SanaPlugin:
    @kernel_function(description="Bugungi sanani qaytaradi")
    def bugungi_sana(self) -> str:
        from datetime import datetime
        return datetime.now().strftime("%Y-%m-%d")
 
 
kernel.add_plugin(SanaPlugin(), plugin_name="sana")

Ikkalasini birlashtirish#

Eng kuchli qism — semantik funksiya ichida tabiiy funksiyani chaqirish:

# Semantik funksiya tabiiy funksiya natijasini ishlatadi
salomlashuv_prompt = """Bugun {{sana.bugungi_sana}}.
Foydalanuvchiga shu sanaga mos, do'stona salomlashuv yoz."""
 
# LLM avval sana funksiyasini chaqiradi, keyin natijadan foydalanadi

Bu — SK'ning falsafasi: hamma narsani funksiya sifatida ko'rish va ularni zanjirga ulash. Tabiiy va semantik funksiyalar bir tilda gaplashadi.

Function calling vs Semantic Kernel#

To'g'ridan-to'g'ri function calling
  • Oddiy, shaffof — protokol ko'rinib turadi
  • Har qanday provayderda ishlaydi
  • Freymvork bog'liqligi yo'q
  • To'liq nazorat
Semantic Kernel
  • Semantik + tabiiy funksiyalar birlashadi
  • Planner avtomatik reja tuzadi
  • Korxona tizimlari uchun tuzilgan
  • Ko'proq mavhumlik, o'rganish kerak

Oddiy agent uchun to'g'ridan-to'g'ri function calling — shaffof va yetarli. Katta, ko'p funksiyali tizim uchun SK'ning tuzilishi va planneri foyda beradi. Avval protokolni tushuning, keyin freymvorkni tanlang.

Amaliy topshiriq

Ko'p funksiyali agent quring

Uch funksiyali agent quring: sana, ob-havo (soxta yoki haqiqiy) va kalkulyator.

Har biriga aniq function ta'rifi yozing. Keyin murakkab so'rov bering, unda model bir necha funksiyani ketma-ket chaqirishi kerak bo'lsin.

Kuzating:

  1. Model qaysi funksiyalarni tanladi va qanday tartibda?
  2. descriptionni yomonlashtirib ko'ring — model funksiyani noto'g'ri tanlaydimi?
  3. Bir funksiyani enum bilan cheklang — natija barqarorroq bo'ladimi?

Bonus: xuddi shu narsani Semantic Kernel bilan takrorlang. Qaysi yondashuv sizga tushunarliroq va nima uchun?

Maslahatni ko'rsatish

To'g'ridan-to'g'ri function calling bilan uch funksiyali agent: def bugungi_sana(): ... # sana def ob_havo(shahar): ... # (soxta yoki haqiqiy API) def hisobla(ifoda): ... # matematik ifoda Har biriga aniq function ta'rifi yozing (description muhim!). Murakkab so'rov bering: «Bugun qaysi kun va Toshkentda ob-havo qanday? Agar 30 darajadan issiq bo'lsa, 30 * 1.8 + 32 ni hisobla.» Model bir necha funksiyani ketma-ket chaqirishi kerak. Kuzating (print bilan): - Model qaysi funksiyalarni tanladi? - Qanday tartibda? - description'ni yomonlashtirib ko'ring — natija o'zgaradimi? Semantic Kernel bilan xuddi shuni takrorlang. Qaysi biri sizga tushunarliroq?

Xulosa#

Yodda saqlang
  • 01LLM funksiyani o'zi ishga tushirmaydi — u faqat so'raydi. Bajarishni sizning kodingiz qiladi. Bu butun protokolning asosi.
  • 02description maydoni — bu prompt. Model faqat shunga qarab funksiya va argument tanlaydi. Aniq yozing, enum ishlatib qiymatlarni cheklang.
  • 03json.loads() bilan argumentlarni tahlil qiling va tool_call_id ni aynan ko'chiring. Bu ikki xato eng ko'p uchraydi.
  • 04Parallel chaqiruvlar tezlikni oshiradi. Barcha natijalarni bitta javobga to'plab qaytaring.
  • 05Semantic Kernel semantik (LLM) va tabiiy (kod) funksiyalarni birlashtiradi. LLM fikrlaydi, kod aniq hisoblaydi — mehnat taqsimoti.
  • 06Avval protokolni tushuning, keyin freymvorkni tanlang. Function calling barcha provayderlarda bir xil ishlaydi.

Keyingi bobda avtonom assistantlar quramiz: behavior tree'lar bilan agentning xatti-harakatini boshqarish va bir necha assistant bir-birini boshqaradigan tizimlar.