Yüksek Lisans ile Otonom Yapay Zeka İş Akışları Oluşturma

Büyük Dil Modelleri (LLM’ler), basit konuşma sohbet robotlarından karmaşık, çok adımlı eylemleri gerçekleştirebilen akıl yürütme motorlarına hızla geçerek teknolojiyle etkileşim şeklimizi değiştirdi. Tek bir istem-yanıt etkileşimi güçlü olabilse de kurumsal ortamlarda üretken yapay zekanın gerçek değeri Otonom Yapay Zeka İş Akışlarında yatmaktadır.

Otonom iş akışları, her adımı yönetmesi için insan operatörlerine güvenmek yerine LLM’leri uzun süreler boyunca görevleri planlayan, yürüten, değerlendiren ve kendi kendini düzelten merkezi karar vericiler olarak kullanır.

Bu ayrıntılı inceleme, modern tasarım modellerini, durum makinelerini ve sağlam korkulukları kullanarak güvenilir otonom yapay zeka iş akışlarının nasıl tasarlanacağını, oluşturulacağını ve dağıtılacağını araştırıyor.

1. Ajans Değişimi: Sohbet Robotları ve İş Akışları

Yüksek Lisans uygulamalarının gelişimi dört farklı özerklik düzeyine ayrılabilir:

Seviye 4 aracıları son derece esnek olsa da, üretim ortamlarında tahmin edilmeleri oldukça zordur. Bu nedenle çoğu kurumsal mimari, yazılım durumu makinelerinin belirleyici güvenilirliğini Yüksek Lisans’ların dinamik akıl yürütmesiyle birleştiren Seviye 3: Yönlendirilmiş İş Akışları üzerine kurulmuştur.

2. Otonom İş Akışlarının Temel Sütunları

Otonom bir iş akışı oluşturmak için dört temel bileşeni birleştirmeniz gerekir:

A. Akıl Yürütme ve Planlama

İş akışının merkezinde planlama paradigması bulunur. Saf bir LLM çağrısı, nihai cevabın hemen çıktısını almaya çalışır ve bu da çoğu zaman muhakeme hatalarına yol açar. Otonom iş akışları özel planlama döngüleri kullanır:

• Tepki Ver (Akıl + Harekete Geç): Model yinelemeli olarak düşünür, hareket eder (bir araç çağırır) ve sonucu gözlemler; hedefe ulaşılana kadar bu döngüyü tekrarlar.
• Düşünce Zinciri (CoT): Modeli bir sonuca varmadan önce adım adım muhakeme yürütmeye zorlamak.
• Düşünce Ağacı (ToT): Birden fazla alternatif yol oluşturma ve değerlendirme, farklı dalları takip etme ve bir yol başarısız olduğunda geriye doğru izleme.

B. Kısa Süreli ve Uzun Süreli Bellek

Otonom bir sistem, birden fazla yürütme döngüsü boyunca durumu korumalıdır:

• Kısa Süreli Bellek: İş akışının o anda ne yaptığını takip eden iş parçacığı bağlamı, durum değişkenleri ve yürütme günlükleri.
• Uzun Süreli Bellek: İş akışının geçmiş çalıştırmaları, kullanıcı tercihlerini ve kurumsal belgeleri hatırlamasına olanak tanıyan vektör veritabanları ve anlamsal erişim sistemleri.

C. Araçlar ve Web Entegrasyonu

Fiziksel veya dijital dünyada hareket etmek için Yüksek Lisans’ların harici hizmetlerle arayüz oluşturması gerekir. Modelin veritabanı sürücülerine, dosya sistemlerine, web tarayıcılarına ve üçüncü taraf API’lere erişmesi gerekiyor. Modern iş akışları, LLM’lerin bağlamsal veri kaynaklarını ve yürütme sanal alanlarını keşfetme ve bunlara güvenli bir şekilde bağlanma şeklini standartlaştıran Model Bağlam Protokolü’nü (MCP) giderek daha fazla benimsiyor.

3. Temel Mimari Tasarım Modelleri

Yazılım mühendisleri, karmaşık etmenli sistemler oluştururken karmaşıklığı yönetmek ve öngörülebilirliği korumak için bir dizi kanıtlanmış tasarım modeline güvenir:

Desen 1: Yönlendirici Deseni

Bir yönlendirici, gelen girdileri okur ve bunu daha sonra hangi özel LLM isteminin, veritabanının veya API işleyicisinin işlemesi gerektiğine karar verir. Bu, tek, yekpare bir LLM isteminin çok fazla talimatla aşırı yüklenmesini önler.

Desen 2: Orkestratör-Çalışanlar

Merkezi bir orkestratör (LLM) büyük, karmaşık bir görevi bağımsız alt görevlere böler. Daha sonra bu görevleri çalışan düğümlerine (uzmanlaşmış LLM’ler veya standart mikro hizmetler olabilir) devreder ve sonuçları sentezler.

Model 3: Değerlendirici-Optimize Edici Döngüsü

Optimize edici bir taslak yanıt oluşturur veya bir görevi yürütür ve değerlendirici bunu resmi kriterlere (birim testleri, güvenlik tarayıcıları veya ayrı bir değerlendirme istemi gibi) göre kontrol eder. Kontrol başarısız olursa, geri bildirim, yanıtı yeniden oluşturmak için optimize ediciye geri iletilir.

4. Python’da Durum Tabanlı Bir Aracı Oluşturmak

Basit bir durum makinesi kullanan özerk bir aracının somut bir uygulamasına bakalım. Geri ödeme taleplerini işleyen bir temsilci tanımlayacağız. Temsilci, müşterinin satın alma geçmişini kontrol eder, talebi politikalara göre doğrular, bir e-posta yanıtı taslağı hazırlar ve geri ödemenin 100 ABD dolarını aşması durumunda insan onayı ister.

import json
from typing import Dict, Any

# Mock databases and tools
PURCHASE_DB = {
    "user_123": {"item": "Premium Subscription", "price": 149.00, "days_ago": 12},
    "user_456": {"item": "Basic License", "price": 49.00, "days_ago": 45}
}

class AutonomousRefundAgent:
    def __init__(self):
        self.state: Dict[str, Any] = {
            "step": "INIT",
            "user_id": None,
            "refund_amount": 0.0,
            "policy_passed": False,
            "requires_approval": False,
            "approved": False,
            "response_draft": "",
            "log": []
        }

    def run(self, user_id: str, request_text: str):
        self.state["user_id"] = user_id
        self.state["log"].append(f"Started workflow for user {user_id} with request: '{request_text}'")
        
        while self.state["step"] != "COMPLETE":
            current_step = self.state["step"]
            if current_step == "INIT":
                self._fetch_user_data()
            elif current_step == "VALIDATE_POLICY":
                self._validate_policy()
            elif current_step == "CHECK_APPROVAL":
                self._check_approval_requirements()
            elif current_step == "WAITING_FOR_HUMAN":
                # Pause execution and yield control back to the orchestrator
                self.state["log"].append("Execution paused: waiting for human operator approval.")
                break
            elif current_step == "EXECUTE_REFUND":
                self._execute_refund()
            elif current_step == "DRAFT_RESPONSE":
                self._draft_response()
                
        return self.state

    def _fetch_user_data(self):
        user_id = self.state["user_id"]
        purchase = PURCHASE_DB.get(user_id)
        if not purchase:
            self.state["response_draft"] = "No purchase history found for this user."
            self.state["step"] = "DRAFT_RESPONSE"
            self.state["log"].append("Fetch failed: User not found in database.")
            return

        self.state["refund_amount"] = purchase["price"]
        self.state["purchase_age_days"] = purchase["days_ago"]
        self.state["step"] = "VALIDATE_POLICY"
        self.state["log"].append(f"Fetched purchase data: {purchase}")

    def _validate_policy(self):
        # Business rule: Refunds only allowed within 30 days
        age = self.state["purchase_age_days"]
        if age <= 30:
            self.state["policy_passed"] = True
            self.state["step"] = "CHECK_APPROVAL"
            self.state["log"].append("Policy validation passed (within 30-day window).")
        else:
            self.state["policy_passed"] = False
            self.state["response_draft"] = "Sorry, our policy only allows refunds within 30 days of purchase."
            self.state["step"] = "DRAFT_RESPONSE"
            self.state["log"].append("Policy validation failed: Purchase older than 30 days.")

    def _check_approval_requirements(self):
        # Business rule: Refunds over $100 require human review
        amount = self.state["refund_amount"]
        if amount > 100.0:
            self.state["requires_approval"] = True
            self.state["step"] = "WAITING_FOR_HUMAN"
            self.state["log"].append(f"Refund of ${amount} exceeds limit. Moving to human approval state.")
        else:
            self.state["requires_approval"] = False
            self.state["step"] = "EXECUTE_REFUND"
            self.state["log"].append(f"Refund of ${amount} is within limits. Proceeding to execution.")

    def resume_with_human_decision(self, approved: bool):
        if self.state["step"] != "WAITING_FOR_HUMAN":
            raise ValueError("Agent is not currently waiting for approval.")
        
        self.state["approved"] = approved
        self.state["log"].append(f"Human manager decision received: Approved = {approved}")
        
        if approved:
            self.state["step"] = "EXECUTE_REFUND"
        else:
            self.state["response_draft"] = "Your refund request has been reviewed and declined by a customer service manager."
            self.state["step"] = "DRAFT_RESPONSE"
            
        # Resume the workflow loop
        return self.run(self.state["user_id"], "")

    def _execute_refund(self):
        amount = self.state["refund_amount"]
        # Trigger actual external API call/Stripe integration here
        self.state["log"].append(f"Successfully processed stripe refund for ${amount}.")
        self.state["response_draft"] = f"Your refund request for ${amount} has been successfully processed."
        self.state["step"] = "DRAFT_RESPONSE"

    def _draft_response(self):
        # Prompt LLM to draft a polite, personalized message incorporating response_draft
        self.state["final_message"] = f"Dear Customer,\n\n{self.state['response_draft']}\n\nBest regards,\nGhaznix Support Agent"
        self.state["step"] = "COMPLETE"
        self.state["log"].append("Customer email drafted successfully. Workflow complete.")

5. Üretim Güvenilirliği ve Güvenlik Korkulukları

Otonom sistemlerin devreye alınması, test etme ve hata yönetimi hakkındaki düşüncelerimizde bir değişiklik gerektirir. Herhangi bir üretim sistemine yerleştirmeniz gereken kritik korkuluklar şunlardır:

A. Kaçak Yürütme Döngülerinin Önlenmesi

Bir hatayla veya uç bir durumla karşılaşan otonom bir aracı, aynı aracı tekrar tekrar sorgulayabilir ve birkaç dakika içinde API maliyetlerine binlerce dolar harcayabilir.

• Çözüm: Maksimum yürütme sınırlarını uygulayın. İş akışı örneği başına izin verilen adım sayısı veya toplam model belirteçleri konusunda her zaman kesin bir tavan tanımlayın (ör. maksimum 10 yineleme).

B. Yapısal Şema Doğrulaması

LLM’ler olasılıksaldır ve geçerli JSON veya eşleşen şemalar gibi yapılandırılmış çıktıları doğal olarak garanti etmez.

• Çözüm: Yapıyı çıkarım düzeyinde uygulamak için Pydantic, Instructor veya Outlines gibi doğrulama kitaplıklarını kullanın. Bir model geçersiz şemaların çıktısını veriyorsa, onu erken reddedin ve ayrıştırma hatası içeren modelin kendisini düzeltmesini isteyin (Değerlendirici-Optimize Edici döngüsünün bir parçası).

C. Kodun Korumalı Alanda Yürütülmesi

Aracınız kod yazıp çalıştırıyorsa (veri analizi veya veritabanı dönüştürmeleri gibi), bunu doğrudan uygulama sunucunuzda çalıştırmak büyük bir güvenlik açığıdır.

• Çözüm: Kullanıcı tarafından oluşturulan veya aracı tarafından oluşturulan komut dosyalarını güvenli bir şekilde çalıştırmak için güvenli, geçici mikro sanal makine ortamlarını (Docker kapsayıcıları, gVisor veya WASM çalışma zamanları gibi) kullanın.

Çözüm

Yüksek Lisans’larla otonom yapay zeka iş akışları oluşturmak, esnek yapay zeka muhakemesi ile yapılandırılmış mühendislik disiplini arasındaki boşluğun kapatılmasını gerektirir. Geliştiriciler, açık uçlu aracıları durum makinesi tarafından yönlendirilen iş akışlarıyla değiştirerek, görevleri Orkestratör-Çalışanlar gibi kalıplarla yapılandırarak ve her şeyi sıkı yürütme ve güvenlik korkuluklarıyla sararak hem son derece akıllı hem de kurumsal kullanıma hazır sistemler oluşturabilir.

Yazılım mimarisinin geleceği, kodu istemlerle değiştirmekle ilgili değil; otonom olarak çalışan, dinamik olarak öğrenen ve sonuçları güvenilir bir şekilde sunan iş akışları oluşturmak için aracıların ve deterministik sistemlerin düzenlenmesiyle ilgilidir.

Ghaznix Blogunda daha fazla yapay zeka mühendisliği makalesini keşfedin →