Agent nima va u qanday quriladi

Fransuz faylasufi Deni Didro shunday degan edi: "Agar har qanday savolga javob bera oladigan to'tiqush topilsa, men uni ikkilanmasdan aqlli mavjudot deb atardim."

Til modeli — juda mukammal to'tiqush. Lekin bir muhim farq bor:

Til modeli gapira oladi, lekin hech narsa qila olmaydi.

U internetga kira olmaydi. Kod ishga tushira olmaydi. Bazaga yoza olmaydi. Kechagi yangilikni bilmaydi.

Agent — aynan shu qutini ochish uchun.

Uch qismli tuzilma#

Agentni tushunishning eng oson yo'li — uni tirik mavjudotga o'xshatish:

1

Miya — LLM va xotira

Ma'lumotni birlashtiradi, qaror qabul qiladi, reja tuzadi. Bu LLM'ning o'zi, ustiga tashqi xotira qo'shilgan holda.

2

Sezgi — kirish kanallari

Matn, rasm, ovoz, sensor ma'lumoti. Modelning dunyoni ko'rish imkoniyatini kengaytiradi.

3

Harakat — asboblar

Qidiruv, kod ishga tushirish, API chaqiruvi, bazaga yozish. Modelning dunyoga TA'SIR QILISH imkoniyati.

To'rt xususiyat#

Agentni oddiy chatbotdan ajratib turadigan narsalar:

Asbob chaqiruvi: protokol ichidan#

Ko'p qo'llanmalar to'g'ridan-to'g'ri LangChain'dan boshlaydi. Natijada odam agent yozadi, lekin nima bo'layotganini bilmaydi — va biror narsa buzilganda nima qilishni ham bilmaydi.

Shuning uchun avval protokolni ko'ramiz.

Asosiy tushuncha#

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

Bu sikl. Model kerak bo'lsa ketma-ket bir necha asbob chaqiradi.

Asbobni e'lon qilish#

import anthropic
 
client = anthropic.Anthropic()
 
asboblar = [
    {
        "name": "ob_havo",
        "description": (
            "Berilgan shahardagi hozirgi ob-havoni qaytaradi. "
            "Foydalanuvchi ob-havo, harorat yoki yomg'ir haqida so'raganda ishlating. "
            "Kelajakdagi prognoz uchun EMAS — faqat hozirgi holat."
        ),
        "input_schema": {
            "type": "object",
            "properties": {
                "shahar": {
                    "type": "string",
                    "description": "Shahar nomi, masalan: Toshkent",
                },
                "birlik": {
                    "type": "string",
                    "enum": ["selsiy", "farengeyt"],
                    "description": "Harorat birligi. Standart: selsiy",
                },
            },
            "required": ["shahar"],
        },
    }
]

Yaxshi tavsif uch narsani aytadi:

Siklni noldan yozamiz#

Endi to'liq ishlaydigan agent. Freymvorksiz.

1. Asboblarni bajaradigan funksiya

   import json
    
    
   def ob_havo(shahar: str, birlik: str = "selsiy") -> str:
       """Haqiqiy loyihada bu yerda API chaqiruvi bo'ladi."""
       malumot = {"Toshkent": 32, "Samarqand": 29, "Nukus": 36}
       harorat = malumot.get(shahar)
    
       if harorat is None:
           return f"'{shahar}' shahri uchun ma'lumot topilmadi"
    
       if birlik == "farengeyt":
           harorat = harorat * 9 / 5 + 32
    
       return f"{shahar}: {harorat}° {birlik}, ochiq havo"
    
    
   def kalkulyator(ifoda: str) -> str:
       """Oddiy matematik ifodani hisoblaydi."""
       ruxsat = set("0123456789+-*/(). ")
       if not set(ifoda) <= ruxsat:
           return "Xato: faqat sonlar va + - * / ( ) belgilariga ruxsat"
       try:
           return str(eval(ifoda, {"__builtins__": {}}, {}))
       except Exception as e:
           return f"Hisoblab bo'lmadi: {e}"
    
    
   BAJARUVCHILAR = {
       "ob_havo": ob_havo,
       "kalkulyator": kalkulyator,
   }

2. Asosiy sikl

   def agent(sorov: str, asboblar: list, maks_qadam: int = 10) -> str:
       """Asbob chaqiruvi siklini boshqaradi."""
       xabarlar = [{"role": "user", "content": sorov}]
    
       for qadam in range(maks_qadam):
           javob = client.messages.create(
               model="claude-opus-5",
               max_tokens=4096,
               tools=asboblar,
               messages=xabarlar,
           )
    
           # Model tugatdimi?
           if javob.stop_reason == "end_turn":
               return "".join(b.text for b in javob.content if b.type == "text")
    
           # Model asbob so'radi
           if javob.stop_reason == "tool_use":
               # Modelning javobini tarixga qo'shamiz — TO'LIQ content bilan
               xabarlar.append({"role": "assistant", "content": javob.content})
    
               natijalar = []
               for blok in javob.content:
                   if blok.type != "tool_use":
                       continue
    
                   print(f"  [{qadam}] {blok.name}({blok.input})")
    
                   try:
                       natija = BAJARUVCHILAR[blok.name](**blok.input)
                       xato = False
                   except Exception as e:
                       natija = f"Asbob xatosi: {e}"
                       xato = True
    
                   natijalar.append({
                       "type": "tool_result",
                       "tool_use_id": blok.id,        # ID MOS KELISHI SHART
                       "content": natija,
                       "is_error": xato,
                   })
    
               # Barcha natijalar BITTA user xabarida
               xabarlar.append({"role": "user", "content": natijalar})
               continue
    
           return f"Kutilmagan holat: {javob.stop_reason}"
    
       return "Qadamlar chegarasiga yetildi"
    
    
   print(agent("Toshkentda havo qanday? Va 32 daraja farengeytda qancha bo'ladi?", asboblar))

3. Natijani ko'ramiz

     [0] ob_havo({'shahar': 'Toshkent'})
     [1] kalkulyator({'ifoda': '32 * 9 / 5 + 32'})
   
   Toshkentda hozir havo ochiq, harorat 32° selsiy.
   Farengeytda bu 89.6° ga to'g'ri keladi.
   

   Model ikkita asbobni ketma-ket chaqirdi va natijalarni birlashtirib javob berdi. Biz hech qanday mantiq yozmadik — faqat asboblarni berdik.

To'rtta muhim detal#

1

tool_use_id mos kelishi shart

Har bir tool_result dagi tool_use_id modelning tool_use blokidagi id bilan aynan bir xil bo'lishi kerak. Bu model qaysi natija qaysi so'rovga tegishli ekanini bilishi uchun.

2

Barcha natijalar bitta xabarda

Model bir vaqtda bir necha asbob so'rasa, ularning natijalarini BITTA user xabarida qaytaring. Alohida-alohida yuborsangiz, model parallel chaqiruvni asta-sekin to'xtatadi.

3

Xatoni ham qaytaring

Asbob ishlamasa, natijani tashlab yubormang. is_error=true bilan qaytaring — model xatoni ko'rib boshqa yo'l tanlashi mumkin.

4

Assistant javobini TO'LIQ qo'shing

javob.content ni butunlay qo'shing, faqat matnini emas. Ichidagi tool_use bloklari keyingi so'rov uchun kerak.

Osonroq yo'l: tool runner#

Siklni tushundingiz. Endi uni SDK'ga topshirsa bo'ladi:

from anthropic import beta_tool
 
 
@beta_tool
def ob_havo(shahar: str, birlik: str = "selsiy") -> str:
    """Berilgan shahardagi hozirgi ob-havoni qaytaradi.
 
    Args:
        shahar: Shahar nomi, masalan Toshkent.
        birlik: Harorat birligi — "selsiy" yoki "farengeyt".
    """
    malumot = {"Toshkent": 32, "Samarqand": 29}
    return f"{shahar}: {malumot.get(shahar, '?')}° {birlik}"
 
 
runner = client.beta.messages.tool_runner(
    model="claude-opus-5",
    max_tokens=4096,
    tools=[ob_havo],
    messages=[{"role": "user", "content": "Toshkentda havo qanday?"}],
)
 
for xabar in runner:
    print(xabar)

Sxema funksiya imzosidan avtomatik yasaladi, docstring esa tavsif bo'ladi. Sikl SDK ichida.

ReAct: o'yla, keyin harakat qil#

Yuqoridagi sikl ReAct naqshining amalga oshirilishi. Nomi ikki so'zdan: Reasoning va Acting.

Fikr:     Foydalanuvchi bugungi valyuta kursini so'rayapti.
          Mening bilimim eskirgan. Qidirish kerak.
Harakat:  qidiruv("bugungi dollar kursi O'zbekiston")
Kuzatish: [natijalar...]
Fikr:     Ma'lumot topildi, javob berish mumkin.
Javob:    Bugungi kurs — ...

Model har qadamda o'z fikrini yozadi. Bu ikki foyda beradi:

1. Model yo'ldan adashmaydi — o'z mantiqini ko'rib turadi
2. Siz uning mantiqini o'qiy olasiz — nosozlikni tuzatish osonlashadi

Vazifani qadamlarga bo'lish#

Haqiqiy vazifalar bir qadamda hal bo'lmaydi. Ikki asosiy strategiya bor.

Boshqa strategiyalar:

• Ko'p reja tanlash — bir vazifaga bir nechta reja tuzib, ko'pchilik ovozi bilan eng yaxshisini tanlash. Qimmat, lekin murakkab holatlarda ishlaydi.
• Refleksiya — model o'z rejasiga o'zi (yoki ikkinchi model) fikr bildiradi. Kuchli, lekin kafolat yo'q — model tuzatish tsiklida qotib qolishi mumkin.

Xotira#

Model xotirasiz. Har so'rovda butun tarix qayta yuboriladi. Bu ikki muammo tug'diradi: kontekst to'ladi va narx o'sadi.

Uchinchi qavat ko'pincha unutiladi, lekin u eng qiymatlisi:

def refleksiya(suhbatlar, client):
    """Xom tajribadan foydalaniladigan bilim chiqaradi."""
    prompt = f"""Quyida agent va foydalanuvchi o'rtasidagi {len(suhbatlar)} ta suhbat bor.
 
Ulardan kelajakda foydali bo'ladigan XULOSALAR chiqaring:
- Bu foydalanuvchi nimani afzal ko'radi?
- Qaysi yondashuvlar ishladi, qaysilari yo'q?
- Qanday xatolar takrorlandi?
 
Har bir xulosani bitta qatorda yozing.
 
{suhbatlar}"""
 
    javob = client.messages.create(
        model="claude-opus-5", max_tokens=1024,
        messages=[{"role": "user", "content": prompt}],
    )
    return "".join(b.text for b in javob.content if b.type == "text")

Natija keyingi suhbatlarda tizim ko'rsatmasiga qo'shiladi. Shunday qilib agent vaqt o'tishi bilan yaxshilanadi.

Kontekstni qisqartirish#

def kontekstni_qisqartir(xabarlar, client, chegara=20):
    """Eski xabarlarni xulosaga almashtiradi."""
    if len(xabarlar) <= chegara:
        return xabarlar
 
    eski = xabarlar[:-10]              # oxirgi 10 tasini saqlaymiz
    yangi = xabarlar[-10:]
 
    xulosa = client.messages.create(
        model="claude-haiku-4-5",      # xulosalash uchun arzon model yetarli
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": f"Quyidagi suhbatni qisqacha xulosalang:\n\n{eski}",
        }],
    )
    matn = "".join(b.text for b in xulosa.content if b.type == "text")
 
    return [{"role": "user", "content": f"[Oldingi suhbat xulosasi]\n{matn}"}] + yangi

Miya uchun modelni tanlash#

Kutubxonalar#

Protokolni tushundingiz. Endi tayyor vositalarni ko'rish mumkin.

Loyiha: tadqiqot agenti#

Endi haqiqiy, foydali agent quramiz. U savol oladi, internetdan qidiradi, natijalarni tahlil qiladi va manbalari ko'rsatilgan javob yozadi.

1. Asboblarni tayyorlash

   import json
   import anthropic
   from duckduckgo_search import DDGS
    
   client = anthropic.Anthropic()
    
    
   def internetdan_qidir(sorov: str, soni: int = 5) -> str:
       """DuckDuckGo orqali qidiradi va natijalarni matn qilib qaytaradi."""
       try:
           with DDGS() as ddgs:
               natijalar = list(ddgs.text(sorov, max_results=soni))
       except Exception as e:
           return f"Qidiruv xatosi: {e}"
    
       if not natijalar:
           return "Hech narsa topilmadi. Boshqa so'rov bilan urinib ko'ring."
    
       qatorlar = []
       for i, n in enumerate(natijalar, 1):
           qatorlar.append(f"[{i}] {n['title']}\n    {n['body'][:300]}\n    Manba: {n['href']}")
       return "\n\n".join(qatorlar)
    
    
   def eslatib_qoy(fakt: str) -> str:
       """Muhim faktni agent xotirasiga yozadi."""
       XOTIRA.append(fakt)
       return f"Saqlandi ({len(XOTIRA)} ta fakt)"
    
    
   XOTIRA: list[str] = []
    
   BAJARUVCHILAR = {
       "internetdan_qidir": internetdan_qidir,
       "eslatib_qoy": eslatib_qoy,
   }

2. Asbob sxemalari

   ASBOBLAR = [
       {
           "name": "internetdan_qidir",
           "description": (
               "Internetdan ma'lumot qidiradi. Bugungi voqealar, statistika, "
               "yangi tadqiqotlar yoki 2025-yildan keyingi har qanday ma'lumot "
               "kerak bo'lganda ishlating. Umumiy bilim savollari uchun kerak emas."
           ),
           "input_schema": {
               "type": "object",
               "properties": {
                   "sorov": {
                       "type": "string",
                       "description": "Qidiruv so'rovi. Aniq va qisqa bo'lsin, "
                                      "masalan: 'O'zbekiston aholisi 2026'",
                   },
                   "soni": {
                       "type": "integer",
                       "description": "Nechta natija kerak. Standart 5, maksimum 10",
                   },
               },
               "required": ["sorov"],
           },
       },
       {
           "name": "eslatib_qoy",
           "description": (
               "Muhim faktni xotiraga yozadi. Yakuniy javobda ishlatiladigan "
               "har bir asosiy faktni topganingizda darhol saqlang."
           ),
           "input_schema": {
               "type": "object",
               "properties": {
                   "fakt": {
                       "type": "string",
                       "description": "Fakt va uning manbasi",
                   },
               },
               "required": ["fakt"],
           },
       },
   ]

3. Agent sinfi

   class TadqiqotAgenti:
       KORSATMA = """Siz sinchkov tadqiqotchisiz.
    
   Qoidalar:
   1. Har bir da'vo uchun manba ko'rsating
   2. Ma'lumot topilmasa — to'qib chiqarmang, "topilmadi" deng
   3. Muhim faktlarni eslatib_qoy bilan saqlang
   4. Bir nechta manbani solishtiring, ziddiyat bo'lsa aytib o'ting
   5. Yakuniy javobda manbalar ro'yxatini bering"""
    
       def __init__(self, model="claude-opus-5", maks_qadam=12):
           self.client = anthropic.Anthropic()
           self.model = model
           self.maks_qadam = maks_qadam
           self.jami_kirish = 0
           self.jami_chiqish = 0
    
       def tadqiq_qil(self, savol: str) -> str:
           XOTIRA.clear()
           xabarlar = [{"role": "user", "content": savol}]
           korilgan = set()
    
           for qadam in range(self.maks_qadam):
               javob = self.client.messages.create(
                   model=self.model,
                   max_tokens=4096,
                   system=self.KORSATMA,
                   tools=ASBOBLAR,
                   messages=xabarlar,
               )
    
               self.jami_kirish += javob.usage.input_tokens
               self.jami_chiqish += javob.usage.output_tokens
    
               if javob.stop_reason == "end_turn":
                   return "".join(b.text for b in javob.content if b.type == "text")
    
               xabarlar.append({"role": "assistant", "content": javob.content})
               natijalar = []
    
               for blok in javob.content:
                   if blok.type != "tool_use":
                       continue
    
                   # Takrorlanuvchi chaqiruvni to'xtatamiz
                   kalit = (blok.name, json.dumps(blok.input, sort_keys=True))
                   if kalit in korilgan:
                       natija, xato = "Bu chaqiruv allaqachon bajarilgan. Boshqa yo'l tanlang.", True
                   else:
                       korilgan.add(kalit)
                       print(f"  [{qadam}] {blok.name}: {blok.input}")
                       try:
                           natija, xato = BAJARUVCHILAR[blok.name](**blok.input), False
                       except Exception as e:
                           natija, xato = f"Asbob xatosi: {e}", True
    
                   natijalar.append({
                       "type": "tool_result",
                       "tool_use_id": blok.id,
                       "content": natija,
                       "is_error": xato,
                   })
    
               xabarlar.append({"role": "user", "content": natijalar})
    
           return "Qadamlar chegarasiga yetildi. Qisman natija:\n" + "\n".join(XOTIRA)
    
       def hisobot(self):
           narx = (self.jami_kirish * 5 + self.jami_chiqish * 25) / 1_000_000
           return (f"tokenlar: {self.jami_kirish:,} → {self.jami_chiqish:,}   "
                   f"narx: ${narx:.4f}")

4. Ishga tushirish

   agent = TadqiqotAgenti()
    
   javob = agent.tadqiq_qil(
       "O'zbekistonda IT sohasidagi eksport 2025-yilda qancha bo'ldi? "
       "Manbalarni ko'rsating."
   )
    
   print(javob)
   print("\n" + agent.hisobot())

     [0] internetdan_qidir: {'sorov': "O'zbekiston IT eksport 2025"}
     [1] eslatib_qoy: {'fakt': 'IT Park maʼlumotiga koʻra... (manba: ...)'}
     [2] internetdan_qidir: {'sorov': "IT Park Uzbekistan export statistics 2025"}
     [3] eslatib_qoy: {'fakt': '...'}
   
   [Yakuniy javob manbalar bilan]
   
   tokenlar: 18,432 → 2,104   narx: $0.1448
   

Agent ishlamasa: nosozliklarni topish#

Xulosa#

Agentimiz endi harakat qila oladi. Lekin uning xotirasi yo'q — topgan narsasini saqlay olmaydi va o'tgan suhbatni eslay olmaydi.

Keyingi bobda aynan shu bo'shliqni to'ldiramiz: RAG.