Çalışan AI Ajanları Oluşturma: Mimari ve Otomasyon

AI ajanları chatbot’lardan temelde farklıdır. Bir chatbot kullanıcı girdisini bekler ve yanıtlar. Bir ajan hedefleri otonom olarak takip eder, araçları çağırır, problemler hakkında akıl yürütür ve her adımda insan müdahalesi olmadan eylem gerçekleştirir.

Bu ayrım önemlidir çünkü ajanlar tüm iş akışlarını otomatikleştirebilir. Bir lead kalifikasyon ajanı potansiyel müşterileri puanlar, verilerini zenginleştirir ve onları satış temsilcilerine atar – tamamen insan müdahalesi olmadan. Bir içerik triyaj ajanı destek biletlerini kategorize eder, uzmanlara yönlendirir ve sınır durumları insanlara iletir.

Bu kılavuzda güvenilir ajanların nasıl mimarileneceğini, bunları iş sistemleriyle nasıl entegre edeceğinizi, yaygın hataları nasıl önleyeceğinizi ve etkilerini nasıl ölçeceğinizi öğreneceksiniz. Lead kalifikasyonunu, belge işlemeyi ve müşteri desteğini büyük ölçekte otomatikleştiren şirketlerde üretimde kullanılan gerçek kalıpları ele alacağız.

AI Ajanları Nedir ve Chatbot’lardan Nasıl Farklıdır?

AI Ajanlarının Tanımı (Algılayan, Karar Veren, Eylem Gerçekleştiren Otonom Sistemler)

Bir AI ajanı şu işlemleri yapan bir yazılım sistemidir:

1. Ortamını algılar (girdi, araç sonuçları, belleği okur)
2. En iyi eylem hakkında akıl yürütür (planlama için LLM kullanır)
3. Araçları çağırarak veya bir hedefe doğru adımlar atarak eylemde bulunur
4. Geri bildirim ve sonuçlara göre uyum sağlar

Ajanlar hedef odaklıdır. Siz hedefi tanımlarsınız (“Bu lead’i puanla ve kalifiye et”) ve ajan onu nasıl başaracağını çözer.

Temel Ayrım: Chatbot’lar Tepkiseldir; Ajanlar Otonomdur

Chatbot’lar: Kullanıcı Başlatır → Model Yanıtlar

User: "What's the status of my order?"
Chatbot: [Looks up order, responds]
User: "Can you cancel it?"
Chatbot: [Cancels order, responds]

Kullanıcı her etkileşimi yönlendirir. Chatbot durumsuzdur—her mesaj bağımsızdır.

Ajanlar: Hedef Odaklı, Her Adımda Kullanıcı Girdisi Olmadan Eylem Gerçekleştirir

Agent goal: "Qualify and score this lead"
1. Agent observes: [Lead data from CRM]
2. Agent reasons: "I need to enrich this data and score them"
3. Agent acts: Calls enrichment API
4. Agent observes: [Enriched data]
5. Agent reasons: "Score is 85, should assign to top sales rep"
6. Agent acts: Updates CRM, sends notification
7. Done. No human input required.

Ajan tanımlanmış bir hedef doğrultusunda çalışır ve otonom olarak birden çok karar ve araç çağrısı yapar.

Ajanlar İş Akışları İçin Neden Önemli?

Ölçekte Otomasyon (İnsan Müdahalesi Olmadan Binlerce Görevi Yönetin)

Manuel lead kalifikasyonu: lead başına 5 dakika × 100 lead = aylık 500 saat. Maliyet: ayda 10.000 $ (saatte 20 $‘dan).

Ajan odaklı: lead başına 10 saniye × 100 lead = aylık 16 saat. Maliyet: 100 $ (ajan API çağrıları). Tasarruf: %99.

Ajanlar işe alım yapmadan ekibinizin kapasitesini çoğaltır.

Çok Adımlı Akıl Yürütme (Karmaşık Problemleri Alt Görevlere Bölme)

Karmaşık görevler birden çok adım gerektirir:

• Lead kalifikasyonu: Puanla → Zenginleştir → Ata → Bildir
• Belge triyajı: Çıkar → Sınıflandır → Yönlendir → Arşivle
• Müşteri desteği: Anla → Bilgi tabanında ara → Yanıt oluştur → Gerekirse yönlendir

Ajanlar bu akıl yürütmeyi otomatik olarak gerçekleştirir. Siz hedefi tanımlarsınız; ajan onu adımlara böler.

Araç Kullanımı (Ajanlar API’ler, Veritabanları, Harici Hizmetler Çağırır)

Ajanlar “ellerdir”. Şu amaçlarla API’leri çağırırlar:

• Veritabanlarını sorgulamak
• CRM sistemlerini güncellemek
• E-posta veya Slack mesajları göndermek
• Üçüncü taraf hizmetleri çağırmak (veri zenginleştirme, ödeme işleme)

Tek bir ajan, bir iş akışını tamamlamak için 5-10 araç çağrısını düzenleyebilir.

Uyarlanabilir Davranış (Geri Bildirimden Öğrenir, Yaklaşımı Ayarlar)

Ajanlar zamanla gelişebilir. Bir ajan belgeleri yanlış sınıflandırırsa, geri bildirim sağlarsınız. Ajan öğrenir ve prompt stratejisini ayarlar.

Bir AI Ajanının Temel Bileşenleri (Ajan Döngüsü)

Ajan Akıl Yürütme Döngüsü (Diyagram Açıklamasıyla)

Her ajanın özü bir döngüdür:

┌─────────────────────────────────────────┐
│  START: Agent receives goal             │
└────────────────┬────────────────────────┘
                 │
                 ▼
┌─────────────────────────────────────────┐
│  OBSERVE: Read input, tool results,     │
│           memory, environment           │
└────────────────┬────────────────────────┘
                 │
                 ▼
┌─────────────────────────────────────────┐
│  REASON: LLM decides next action        │
│          (which tool to call, or done?) │
└────────────────┬────────────────────────┘
                 │
                 ▼
┌─────────────────────────────────────────┐
│  ACT: Execute tool call or complete     │
│       task                              │
└────────────────┬────────────────────────┘
                 │
                 ▼
┌─────────────────────────────────────────┐
│  FEEDBACK: Evaluate result, update      │
│            memory, check if goal met    │
└────────────────┬────────────────────────┘
                 │
                 ├─→ Goal not met? Loop back to OBSERVE
                 │
                 └─→ Goal met or max steps reached? DONE

Gözlem: Ajan Durumu Algılar (Girdi, Ortam, Araç Sonuçları)

Ajan şunları okur:

• İlk girdi (lead verisi, belge metni, müşteri sorusu)
• Önceki adımlardan araç sonuçları (API yanıtları, veritabanı sorguları)
• Bellek (konuşma geçmişi, geçmiş kararlar, bilgi tabanı)
• Mevcut durum (ne yapıldı, ne kaldı)

Akıl Yürütme: LLM Sonraki Eyleme Karar Verir (Planlama, Araç Seçimi)

LLM şu gibi bir prompt alır:

You are a lead qualification agent. Your goal is to score and qualify this lead.

Available tools:
1. enrich_lead(lead_id) - Get additional data about the lead
2. score_lead(lead_data) - Score based on criteria
3. assign_to_sales_rep(lead_id, rep_id) - Assign lead to a rep
4. send_notification(rep_id, message) - Notify rep

Current state:
- Lead ID: 12345
- Company: Acme Corp
- Revenue: Unknown (need to enrich)
- Status: Not scored yet

What should you do next?

LLM yanıtı: “Önce gelir verisi almak için lead’i zenginleştirmeliyim, sonra puanlamalı, sonra atamalıyım.”

Eylem: Araç Çağrısını Yürüt veya Hedefe Doğru Adım At

Ajan seçilen aracı yürütür:

result = enrich_lead(lead_id=12345)
# Returns: {'revenue': '$10M', 'industry': 'SaaS', 'employees': 150}

Geri Bildirim: Sonucu Değerlendir, Gerekirse Stratejiyi Ayarla

Ajan kontrol eder: Araç çağrısı başarılı oldu mu? Hedefe yaklaştı mı? Belleği güncelle ve döngüye devam et.

Döngü: Hedefe Ulaşılana veya Maksimum Adıma Kadar Tekrarla

Ajan gözlem → akıl yürütme → eylem → geri bildirim döngüsünü şu koşullara kadar tekrarlar:

• Hedefe ulaşıldı (“Lead puanlandı ve atandı”)
• Maksimum adıma ulaşıldı (sonsuz döngüleri önle)
• Hata oluştu (insana eskale et)

Araç Entegrasyonu (Ajanın “Elleri”)

Araçları Tanımlama (Fonksiyon İmzaları, Açıklamalar, Parametreler)

Araçlar, ajanın çağırabileceği fonksiyonlardır. Bunları açıkça tanımlayın:

tools = [
    {
        "name": "enrich_lead",
        "description": "Get additional company data about a lead (revenue, employees, industry)",
        "parameters": {
            "lead_id": {"type": "string", "description": "Unique identifier of the lead"}
        }
    },
    {
        "name": "score_lead",
        "description": "Score a lead on a scale of 0-100 based on fit criteria",
        "parameters": {
            "lead_data": {"type": "object", "description": "Lead information including revenue, industry, etc."}
        }
    }
]

Açık açıklamalar LLM’nin doğru aracı seçmesine yardımcı olur.

Araç Çağırma (Ajanlar Araçları Nasıl Seçer ve Çağırır)

LLM bir araç çağrısıyla yanıt verir:

{
  "thought": "I need to enrich this lead to get revenue data",
  "action": "enrich_lead",
  "action_input": {"lead_id": "12345"}
}

Ajan framework’ünüz aracı yürütür ve sonucu LLM’ye geri iletir.

Araç Sonucu Yönetimi (Yanıtları Ayrıştırma, Hata Kurtarma)

Hem başarıyı hem de başarısızlığı yönetin:

def execute_tool(tool_name, tool_input):
    try:
        if tool_name == "enrich_lead":
            result = crm_api.enrich(tool_input['lead_id'])
            return {"status": "success", "data": result}
    except Exception as e:
        return {"status": "error", "message": str(e)}

Bir araç başarısız olursa, ajan farklı bir yaklaşım denemeli veya insana eskale etmelidir.

Bellek Sistemleri (Ajanlar Neyi Hatırlar)

Kısa Süreli Bellek (Mevcut Konuşma Bağlamı)

Ajanın çalışma belleği: mevcut girdi, araç sonuçları, akıl yürütme adımları. Genellikle bağlam penceresinde (prompt) saklanır.

Örnek: Lead kalifikasyon ajanı şunları hatırlar:

• Orijinal lead verisi
• Zenginleştirme sonuçları
• Puan
• Hangi satış temsilcisine atandığı

Uzun Süreli Bellek (Bilgi Tabanı, Geçmiş Etkileşimler)

Kalıcı bellek: geçmiş kararlar, öğrenilen kalıplar, bilgi tabanı.

Kullanım durumları:

• Bilgi tabanı: Ajan müşteri sorularını yanıtlarken ilgili makaleleri alır
• Karar geçmişi: Ajan hangi lead’lerin dönüştüğünü öğrenir (puanlamayı iyileştirir)
• Etkileşim günlükleri: Ajan bir müşteriyle geçmiş etkileşimleri hatırlar

Anlamsal arama için vektör veritabanları (Pinecone, Weaviate) ile uygulayın.

Bellek Sınırlamaları (Bağlam Penceresi Kısıtlamaları)

LLM’lerin sınırlı bağlam pencereleri vardır (4K-128K token). Ajanlar her şeyi hatırlayamaz. Stratejiler:

• Özetleme: Eski konuşmaları özetlere sıkıştırın
• Retrieval-augmented generation (RAG): Yalnızca gerektiğinde ilgili belleği getirin
• Hiyerarşik bellek: Yakın etkileşimleri kısa süreli, eskileri uzun süreli bellekte tutun

Akıl Yürütme Omurgası (“Beyin”)

LLM Seçimi (GPT-4, Claude, Açık Kaynak Modeller)

• GPT-4: En iyi akıl yürütme, karmaşık görevleri yönetir. Maliyet: 1K token başına 0,03-0,06 $.
• Claude 3.5 Sonnet: Güçlü akıl yürütme, uzun bağlam (200K token). Maliyet: 1K token başına 0,003-0,015 $.
• Açık kaynak (LLaMA 4): Daha ucuz (1M token başına 0,01-0,03 $), özelleştirilebilir, gizlilik dostu.

Çoğu ajan için Claude veya açık kaynak modeller yeterlidir ve daha ucuzdur.

Akıl Yürütme Modları (Chain-of-Thought, Tree-of-Thought, Reflexion)

• Chain-of-thought: Ajan adım adım düşünür. “Zenginleştirmeliyim → puanlamalıyım → atamalıyım.”
• Tree-of-thought: Ajan birden çok yol keşfeder, en iyisini seçer. Daha yavaş ama karmaşık problemlerde daha doğru.
• Reflexion: Ajan kendi çıktısını eleştirir, gerekirse yeniden dener. Halüsinasyonları azaltır.

Örnek reflexion promptu:

Agent: "I'll assign this lead to rep John."
Critic: "Wait, did you check if John is already at capacity?"
Agent: "Good point. Let me check John's workload first."

Takaslar: Hız ve Doğruluk

• Hızlı ajanlar: Tek turlu akıl yürütme, araç doğrulaması yok. Görev başına 2-5 saniye. %85 doğruluk.
• Doğru ajanlar: Çok adımlı akıl yürütme, doğrulama, reflexion. Görev başına 10-30 saniye. %95 doğruluk.

Gerçek zaman için hızı seçin (müşteri desteği). Yüksek riskli durumlar için doğruluğu seçin (finansal kararlar).

İşinizi büyütmeye hazır mısınız?

Bugün ücretsiz denemenizi başlatın ve günler içinde sonuçları görün.

Demo talep et Giriş yap

Ajan Türleri ve Hangisini Ne Zaman Kullanmalısınız

Tepkisel Ajanlar (Basit, Hızlı, Durumsuz)

Nasıl Çalışır (Tek Tur: Girdi → Eylem)

Tepkisel ajanlar tek bir karar verir ve eylemde bulunur. Çok adımlı planlama yok.

Input: "What's my account balance?"
→ Agent queries database
→ Agent responds with balance
Done.

En Uygun: Basit Araç Kullanımı, API Çağrıları, Anında Yanıtlar

• Müşteri hizmetleri S&C (sipariş arama, bakiye kontrolü)
• Basit API çağrıları (hava durumu, hisse senedi fiyatı)
• Anında yanıt gerekir (< 2 saniye gecikme)

Örnek: Bilgi Tabanı Aramalı Müşteri Hizmetleri Chatbot’u

def customer_service_agent(question):
    # 1. Search knowledge base
    articles = search_kb(question)
    
    # 2. LLM picks best article
    response = llm.complete(f"""
        Question: {question}
        Relevant articles: {articles}
        Provide an answer based on these articles.
    """)
    
    # 3. Return response
    return response

Gecikme: 1-3 saniye. Maliyet: sorgu başına 0,001-0,01 $.

Planlama Ajanları (Hedef Odaklı, Çok Adımlı Akıl Yürütme)

Nasıl Çalışır (Hedefi Alt Görevlere Bölme, Planı Yürütme)

Planlama ajanları karmaşık hedefleri adımlara böler.

Goal: "Qualify and assign this lead"
→ Agent plans: [enrich, score, assign, notify]
→ Agent executes each step
→ Agent verifies goal achieved
Done.

En Uygun: Karmaşık İş Akışları, Araştırma Görevleri, Veri Analizi

• Lead kalifikasyonu (zenginleştir → puanla → ata)
• Belge işleme (çıkar → sınıflandır → depola)
• Araştırma görevleri (ara → özetle → derle)

Örnek: Lead Kalifikasyon Ajanı (Puanla → Zenginleştir → Ata)

def lead_qualification_agent(lead_id):
    lead = crm.get_lead(lead_id)
    
    # Step 1: Enrich
    enriched = enrich_lead(lead)
    
    # Step 2: Score
    score = score_lead(enriched)
    
    # Step 3: Assign
    best_rep = find_best_sales_rep(score)
    crm.assign_lead(lead_id, best_rep)
    
    # Step 4: Notify
    send_slack(f"New qualified lead assigned to {best_rep}")
    
    return {"lead_id": lead_id, "score": score, "assigned_to": best_rep}

Gecikme: 5-15 saniye. Maliyet: lead başına 0,02-0,05 $.

Öğrenen Ajanlar (Uyarlanabilir, Zamanla Gelişir)

Nasıl Çalışır (Geri Bildirimi Dahil Eder, Davranışı Ayarlar)

Öğrenen ajanlar geri bildirimle daha iyiye gider.

Initial: Agent classifies document as "Invoice" (60% confidence)
Human feedback: "Actually, it's a Receipt"
Agent learns: Adjust classification prompts
Next time: Same document classified as "Receipt" (90% confidence)

En Uygun: Uzun Süreli Süreçler, Kişiselleştirme, Optimizasyon

• İçerik önerisi (kullanıcı tercihlerini öğrenir)
• Müşteri destek yönlendirmesi (hangi ajanın hangi konuları en iyi yönettiğini öğrenir)
• Fiyat optimizasyonu (hangi fiyatların en iyi dönüştüğünü öğrenir)

Örnek: İçerik Öneri Ajanı (Kullanıcı Tercihlerini Öğrenir)

def recommendation_agent(user_id):
    # Get user history
    history = db.get_user_history(user_id)
    
    # LLM recommends based on patterns
    recommendation = llm.complete(f"""
        User history: {history}
        Based on past preferences, what should we recommend?
    """)
    
    # Show recommendation, collect feedback
    feedback = user_feedback  # thumbs up/down
    
    # Store feedback for future recommendations
    db.log_feedback(user_id, recommendation, feedback)
    
    return recommendation

Ajan kullanıcı tercihlerini öğrendikçe öneriler zamanla gelişir.

Hiyerarşik Ajanlar (Diğer Ajanları Yöneten Ajanlar)

Nasıl Çalışır (Denetleyici Ajan Uzmanlara Delege Eder)

Bir denetleyici ajan uzman ajanları koordine eder.

Supervisor: "Process this support ticket"
├─ Classifier agent: "This is a billing issue"
├─ Billing specialist agent: "Refund $50"
└─ Notification agent: "Send confirmation email"

En Uygun: Kurumsal İş Akışları, Büyük Ölçekli Otomasyon

• İçerik oluşturma (araştırma → yazma → düzenleme → yayınlama ajanları)
• Karmaşık müşteri desteği (triyaj → çözüm → eskalasyon ajanları)
• Veri işleme pipeline’ları (çıkarma → dönüştürme → yükleme ajanları)

Örnek: İçerik Oluşturma Pipeline’ı (Araştırma → Yazma → Düzenleme → Yayınlama)

def content_pipeline_agent(topic):
    # Supervisor delegates
    research = research_agent(topic)
    draft = writer_agent(research)
    edited = editor_agent(draft)
    published = publisher_agent(edited)
    
    return {"topic": topic, "status": "published"}

Her uzman ajan kendi görevi için optimize edilmiştir. Denetleyici orkestrasyon yapar.

2026’da En İyi AI Ajan Araçları ve Framework’leri (Karşılaştırma Tablosu)

Değerlendirme Kriterleri

Akıl Yürütme Yeteneği (Chain-of-Thought, Planlama, Reflexion)

Ajanın düşünmesinin ne kadar karmaşık olduğu. Basit ajanlar chain-of-thought kullanır. Karmaşık ajanlar planlama ve reflexion kullanır.

Araç Entegrasyonu (Özel Araçları Eklemek Ne Kadar Kolay)

API’leri, veritabanlarını, CRM sistemlerini kolayca bağlayabilir misiniz? Yoksa özel kod mu gerekir?

Öğrenme Eğrisi (Kurulum Süresi, Dokümantasyon Kalitesi)

Bir geliştirici ne kadar hızlı çalışan bir ajan elde edebilir? Kodsuz platformlar daha hızlıdır; Python framework’leri daha esnektir.

Fiyatlandırma Modeli (Ücretsiz, API Çağrısı Başına, Abonelik)

Bazı framework’ler açık kaynaklıdır (ücretsiz). Diğerleri API çağrısı başına veya abonelik ücreti alır.

En İyi Kullanım Durumları

Her araç ne için optimize edilmiştir?

Karşılaştırma Tablosu: En İyi AI Ajan Araçları ve Framework’leri (2026)

Temel farklar:

• Kodsuz (n8n, FlowHunt, Lindy.ai): Hızlı oluşturulabilir, sınırlı özelleştirme. Standart iş akışları için iyidir.
• Python framework’ler (CrewAI, Autogen, LangGraph): Esnek, güçlü, daha dik öğrenme eğrisi. Karmaşık mantık için iyidir.
• Açık kaynak (CrewAI, Autogen, LangGraph): Ücretsiz, ancak altyapıyı siz yönetirsiniz. Ücretli platformlar barındırmayı halleder.

Kullanım Durumunuz İçin Doğru Aracı Nasıl Seçersiniz

• Hızlı prototip (< 1 hafta): Kodsuz kullanın (FlowHunt, n8n, Lindy.ai)
• Özel mantığa sahip karmaşık ajan: Python framework kullanın (CrewAI, LangGraph)
• Çok ajanlı sistem (ajanlar koordinasyon halinde): Autogen kullanın
• Üretim iş akışı otomasyonu: FlowHunt kullanın (yönetilen, izlenen, ölçeklenen)

Bültenimize katılın

En son ipuçlarını, trendleri ve teklifleri ücretsiz alın.

E-posta adresi

Abone ol

İlk Ajanınızı Oluşturma: Adım Adım Mimari

Ajanın Hedefini ve Kapsamını Tanımlayın

Hangi Problemi Çözer?

Spesifik olun. Kötü: “Lead yönetimini otomatikleştir.” İyi: “Lead’leri 0-100 puanla, şirket verisiyle zenginleştir, kapasiteye göre satış temsilcilerine ata.”

Başarı Ölçütleri Nelerdir?

• Doğruluk: doğru kararların yüzdesi (hedef: > %90)
• Gecikme: görevi tamamlama süresi (hedef: < 10 saniye)
• Maliyet: görev başına API çağrıları (hedef: < 0,05 $)
• Otomasyon oranı: insan müdahalesi olmadan tamamlanan görev yüzdesi (hedef: > %80)

Kısıtlamalar Nelerdir (Gecikme, Maliyet, Doğruluk)?

Takaslar:

• Gerçek zamanlı iş akışları: < 5 saniye gecikme gerekir. Hızlı modeller, daha az araç çağrısı kullanın.
• Toplu iş akışları: 5-30 dakikaya tolerans gösterebilir. Daha doğru akıl yürütme, daha fazla araç çağrısı kullanın.
• Maliyet hassas: Açık kaynak modeller, daha az API çağrısı kullanın.
• Doğruluk kritik: Pahalı modeller (GPT-4), çok adımlı doğrulama kullanın.

Ajan Döngüsünü Tasarlayın

Ajan Neyi Gözlemleyecek?

Girdi verisi: lead verisi, belge metni, müşteri sorusu, bellekten bağlam.

Hangi Akıl Yürütme Modu (Basit Chain-of-Thought vs. Planlama)?

• Chain-of-thought: Hızlı, basit. “Adım 1’i yapacağım, sonra adım 2’yi.”
• Planlama: Daha yavaş, daha doğru. “Önce tüm adımları planlayayım, sonra yürüteyim.”

Hangi Araçlara İhtiyacı Var?

Ajanın çağıracağı API’leri, veritabanlarını, hizmetleri listeleyin.

Lead kalifikasyonu için örnek:

• CRM API (lead al/güncelle)
• Veri zenginleştirme API (şirket verisini al)
• Puanlama modeli (lead’i puanla)
• Bildirim hizmeti (Slack/e-posta gönder)

Ne Zaman Duracağını Nasıl Bilir?

Başarı koşulunu tanımlayın. “Lead puanlandığında ve atandığında dur.”

Ayrıca sonsuz döngüleri önlemek için maksimum adım tanımlayın. “10 adımdan sonra her şekilde dur.”

Uygulama ve Test

Sözde Kod veya Gerçek Kod Örneği (CrewAI veya FlowHunt)

CrewAI örneği:

from crewai import Agent, Task, Crew

# Define agents
enrichment_agent = Agent(
    role="Data Enrichment Specialist",
    goal="Enrich lead data with company information",
    tools=[enrich_tool]
)

scoring_agent = Agent(
    role="Lead Scoring Expert",
    goal="Score leads based on fit criteria",
    tools=[score_tool]
)

assignment_agent = Agent(
    role="Sales Manager",
    goal="Assign leads to best sales rep",
    tools=[assign_tool, notify_tool]
)

# Define tasks
enrich_task = Task(
    description="Enrich this lead: {lead_id}",
    agent=enrichment_agent
)

score_task = Task(
    description="Score the enriched lead",
    agent=scoring_agent
)

assign_task = Task(
    description="Assign lead to best rep and notify",
    agent=assignment_agent
)

# Run crew
crew = Crew(agents=[enrichment_agent, scoring_agent, assignment_agent],
            tasks=[enrich_task, score_task, assign_task])
result = crew.kickoff(inputs={"lead_id": "12345"})

Test Stratejisi (Araç Çağrıları İçin Birim Testleri, Döngüler İçin Entegrasyon Testleri)

def test_enrichment_tool():
    result = enrich_tool("lead_123")
    assert result['revenue'] is not None
    assert result['employees'] is not None

def test_scoring_agent():
    lead = {"company": "Acme", "revenue": "10M", "employees": 50}
    score = score_agent(lead)
    assert 0 <= score <= 100

def test_full_loop():
    result = lead_qualification_agent("lead_123")
    assert result['assigned_to'] is not None
    assert result['score'] > 0

Yaygın Sorunları Ayıklama (Sonsuz Döngüler, Halüsinasyonlar, Yanlış Araçlar)

• Sonsuz döngüler: Maksimum adım sınırı ekleyin. Her adımı günlüğe kaydedin. Tekrarlanan eylemleri izleyin.
• Halüsinasyonlar: Doğrulama ekleyin. Çıktıları kaynak verilerle karşılaştırıp gerçek kontrolü yapın.
• Yanlış araçlar: Araç açıklamalarını iyileştirin. Yürütmeden önce araç doğrulaması ekleyin.

Gerçek Örnek: Lead Kalifikasyon Ajanı

Hedef: Lead’leri Puanla, Veriyi Zenginleştir, Satış Ekibine Ata

def lead_qualification_agent(lead_id):
    """
    Autonomous agent that qualifies leads.
    1. Fetches lead from CRM
    2. Enriches with company data
    3. Scores based on fit criteria
    4. Assigns to best sales rep
    5. Notifies rep
    """

Araçlar: CRM API, Veri Zenginleştirme Hizmeti, Puanlama Modeli

tools = {
    "get_lead": crm.get_lead,
    "enrich_lead": enrichment_api.enrich,
    "score_lead": scoring_model.score,
    "find_best_rep": crm.find_available_rep,
    "assign_lead": crm.assign,
    "send_notification": slack.send
}

Sözde Kod Gezintisi (Lead’i Gözlemle → Puanla → Zenginleştir → Ata)

# Step 1: Observe
lead = get_lead(lead_id)
print(f"Observing lead: {lead['company']}")

# Step 2: Reason (LLM decides next action)
# LLM: "I need to enrich this lead first"

# Step 3: Act
enriched = enrich_lead(lead)
print(f"Enriched: revenue={enriched['revenue']}")

# Step 4: Feedback + Loop
# LLM: "Now I'll score"

# Step 5: Act
score = score_lead(enriched)
print(f"Score: {score}")

# Step 6: Reason
# LLM: "Score is {score}, should assign to top rep"

# Step 7: Act
best_rep = find_best_rep(score)
assign_lead(lead_id, best_rep)
send_notification(best_rep, f"New lead: {lead['company']}")

print(f"Assigned to {best_rep}")

Sonuçlar: Doğruluk, Gecikme, Maliyet Ölçütleri

• Doğruluk: %94 (lead puanı manuel inceleme ile eşleşir)
• Gecikme: 8 saniye (5 araç çağrısı, 3 LLM akıl yürütme adımı)
• Maliyet: Lead başına 0,03 $ (GPT-4 API çağrıları + zenginleştirme API’si)
• Verim: Saatte 450 lead (tek ajan örneği)
• Otomasyon oranı: %87 (%13 inceleme için insana eskale edildi)

Ajanları İş Sistemleriyle Entegre Etme

API Entegrasyon Kalıpları

REST API’leri (En Yaygın)

Çoğu ajan REST API’lerini çağırır. Standart HTTP istemcisi kullanın:

def call_crm_api(endpoint, method="GET", data=None):
    url = f"https://api.crm.com/{endpoint}"
    headers = {"Authorization": f"Bearer {api_key}"}
    
    if method == "GET":
        response = requests.get(url, headers=headers)
    elif method == "POST":
        response = requests.post(url, json=data, headers=headers)
    
    return response.json()

Webhook’lar (Olay Tabanlı Ajan Tetikleyicileri)

Ajanları olaylar üzerine tetikleyin (yeni lead, gelen e-posta, form gönderimi):

@app.post("/webhook/new_lead")
def on_new_lead(lead_data):
    # Trigger agent asynchronously
    queue.enqueue(lead_qualification_agent, lead_data['id'])
    return {"status": "queued"}

Kimlik Doğrulama ve Güvenlik (API Anahtarları, OAuth, Hız Sınırlama)

• API anahtarları: Kodda değil, ortam değişkenlerinde saklayın
• OAuth: Kullanıcıya yönelik entegrasyonlar için (Salesforce, HubSpot)
• Hız sınırlama: API sınırlarına saygı gösterin. Backoff ve yeniden deneme mantığı uygulayın

from ratelimit import limits, sleep_and_retry

@sleep_and_retry
@limits(calls=100, period=60)  # 100 calls per minute
def call_api(endpoint):
    return requests.get(f"https://api.example.com/{endpoint}")

Veritabanı Entegrasyonu

Salt Okunur (Ajan Veriyi Sorgular)

Ajan müşteri verilerini, geçmiş etkileşimleri, bilgi tabanını okur:

def get_customer_history(customer_id):
    query = "SELECT * FROM interactions WHERE customer_id = %s"
    return db.execute(query, (customer_id,))

Yazma İşlemleri (Ajan Kararları/Sonuçları Saklar)

Ajan kararları veritabanına yazar:

def store_lead_score(lead_id, score, assigned_to):
    db.execute(
        "UPDATE leads SET score = %s, assigned_to = %s WHERE id = %s",
        (score, assigned_to, lead_id)
    )

İşlemler ve Tutarlılık (Veri Bütünlüğünü Sağlama)

Çok adımlı işlemler için işlemleri kullanın:

with db.transaction():
    score = score_lead(lead)
    db.update_lead_score(lead_id, score)
    rep = find_best_rep(score)
    db.assign_lead(lead_id, rep)
    # All-or-nothing: if any step fails, rollback

CRM ve İş Aracı Entegrasyonu

Salesforce, HubSpot, Pipedrive Entegrasyon Kalıpları

Resmi SDK’ları kullanın:

from salesforce import SalesforceAPI

sf = SalesforceAPI(api_key=key)

# Update lead
sf.update_lead(lead_id, {
    'score': 85,
    'assigned_to': 'john@acme.com',
    'status': 'qualified'
})

Slack, E-posta, Jira Entegrasyonu (Ajan Bildirim/Güncelleme Gönderir)

from slack_sdk import WebClient

slack = WebClient(token=slack_token)

# Notify sales rep
slack.chat_postMessage(
    channel="john",
    text=f"New qualified lead: {lead['company']} (score: {score})"
)

Kimlik Doğrulama ve İzin Kapsamı

Ajanların neler yapabileceğini sınırlamak için OAuth scope’ları kullanın:

# Agent can only read leads, update scores
# Cannot delete leads or access sensitive data
oauth_scopes = ["leads:read", "leads:update"]

Human-in-the-Loop İş Akışları

Ajanlar Ne Zaman İnsan Onayına İhtiyaç Duyar

Yüksek riskli kararlar: finansal işlemler, müşteri iadeleri, politika istisnaları.

if decision_risk_score > 0.7:
    # Route to human for approval
    escalate_to_human(decision, reason="High risk")
else:
    # Agent executes decision
    execute_decision(decision)

Eskalasyon Kalıpları (Yüksek Riskli Kararlar, Sınır Durumlar)

def lead_qualification_with_escalation(lead_id):
    score = score_lead(lead_id)
    
    if score > 80:
        # High confidence, assign directly
        assign_lead(lead_id, best_rep)
    elif 50 < score < 80:
        # Medium confidence, route to human
        escalate_to_human(lead_id, "Review and assign")
    else:
        # Low score, reject
        reject_lead(lead_id)

Geri Bildirim Döngüleri (İnsanlar Ajan Hatalarını Düzeltir)

@app.post("/feedback/lead_score")
def on_score_feedback(lead_id, actual_score, agent_score):
    # Store feedback
    db.log_feedback(lead_id, agent_score, actual_score)
    
    # Retrain model on feedback (periodic)
    if should_retrain():
        retrain_scoring_model()

Yaygın Ajan Hataları ve Bunları Nasıl Önlersiniz

Sonsuz Döngüler (Ajan Aynı Eylemi Tekrarlayarak Takılı Kalır)

Sebep: Zayıf Hedef Tanımı, İlerleme Sağlamayan Araç

# Bad: Agent keeps calling same tool
Agent thinks: "I need to get lead data"
→ Calls get_lead()
→ Still doesn't have enriched data
→ Calls get_lead() again
→ Infinite loop

Önleme: Maksimum Adım Sınırı, İlerleme Takibi, Araç Çeşitliliği

max_steps = 10
steps_taken = 0

while steps_taken < max_steps:
    action = llm.decide_next_action()
    
    if action == last_action:
        # Same action twice, break loop
        break
    
    execute_action(action)
    steps_taken += 1

Kurtarma: Zaman Aşımı, İnsana Eskalasyon

try:
    result = agent.run(timeout=30)  # 30 second timeout
except TimeoutError:
    escalate_to_human("Agent loop timeout")

Halüsinasyonlar (Ajan Gerçekleri veya Araç Çıktılarını Uydurur)

Sebep: LLM’nin Uydurma Eğilimi, Zayıf Araç Açıklamaları

# Bad: Agent hallucinates tool output
Agent: "I called enrich_lead, got revenue=$100M"
Reality: enrich_lead() returned null (API failed)
Agent made up the result

Önleme: Retrieval-Augmented Generation (RAG), Araç Doğrulaması, Gerçek Kontrolü

def execute_tool_safely(tool_name, params):
    try:
        result = execute_tool(tool_name, params)
        
        # Validate result
        if result is None:
            return {"error": "Tool returned null"}
        
        if not validate_result(result):
            return {"error": "Result failed validation"}
        
        return result
    except Exception as e:
        return {"error": str(e)}

Ajanı gerçeklere dayandırmak için RAG kullanın:

# Instead of: "Summarize this article"
# Use: "Summarize this article, citing specific passages"

knowledge_base = vector_db.search(query)
prompt = f"""
Summarize this article. Only cite specific passages.
Article: {article}
Knowledge base: {knowledge_base}
"""

Kurtarma: İnsana Yedekleme, Farklı Akıl Yürütmeyle Yeniden Deneme

def robust_agent_call(goal, retries=3):
    for attempt in range(retries):
        try:
            result = agent.run(goal)
            
            # Validate result
            if validate(result):
                return result
        except Exception as e:
            if attempt == retries - 1:
                escalate_to_human(goal)
            else:
                time.sleep(2 ** attempt)  # Backoff

Araç Kötüye Kullanımı (Ajan Yanlış Araç veya Yanlış Parametrelerle Çağırır)

Sebep: Belirsiz Araç Açıklamaları, Zayıf Akıl Yürütme

# Bad: Ambiguous tool description
"update_lead - Update a lead"

# Good: Clear description
"update_lead - Update a lead's score, status, or assigned_to field. 
Parameters: lead_id (required), score (0-100), status (qualified/disqualified), 
assigned_to (sales rep email)"

Önleme: Açık Araç Dokümantasyonu, Araç Kullanım Eğitimi, Yürütmeden Önce Doğrulama

# Validate before execution
tool_call = llm.decide_tool_call()

if not validate_tool_call(tool_call):
    # Tool call is invalid, ask LLM to fix
    llm.correct_tool_call(tool_call)
else:
    execute_tool(tool_call)

def validate_tool_call(call):
    tool = tools[call['name']]
    required_params = tool['required_parameters']
    
    for param in required_params:
        if param not in call['params']:
            return False
    
    return True

Kurtarma: Hata Yönetimi, Doğru Aracı Önerme, Yeniden Deneme

try:
    result = execute_tool(tool_call)
except ToolExecutionError as e:
    # Suggest correct tool
    correct_tool = suggest_correct_tool(e)
    llm.suggest_retry(correct_tool)

Maliyet Aşımları (Ajan Çok Fazla API Çağrısı Kullanır)

Sebep: Verimsiz Akıl Yürütme, Gereksiz Araç Çağrıları

# Bad: Agent calls same tool multiple times
Agent: "Let me get lead data"
→ Calls get_lead()
→ Calls get_lead() again (forgot it already did)
→ Calls get_lead() a third time
Cost: 3x higher than needed

Önleme: Bütçe Sınırları, Çağrı Tekrarını Kaldırma, Önbellekleme

budget = {"tokens": 10000, "api_calls": 50}
spent = {"tokens": 0, "api_calls": 0}

def execute_with_budget(action):
    global spent
    
    if spent['api_calls'] >= budget['api_calls']:
        raise BudgetExceededError()
    
    result = execute_action(action)
    spent['api_calls'] += 1
    
    return result

Önbelleklemeyi uygulayın:

cache = {}

def get_lead_cached(lead_id):
    if lead_id in cache:
        return cache[lead_id]
    
    result = crm_api.get_lead(lead_id)
    cache[lead_id] = result
    return result

Kurtarma: Maliyet İzleme, Kısıtlama, Daha Ucuz Model Yedekleme

if cost_this_hour > budget_per_hour:
    # Switch to cheaper model
    switch_to_model("gpt-3.5-turbo")  # Cheaper than GPT-4

Gecikme Sorunları (Ajan Gerçek Zamanlı Kullanım İçin Çok Yavaş)

Sebep: Birden Çok Akıl Yürütme Adımı, Yavaş Araç Yanıtları

Her biri 1 saniye süren 5 ardışık API çağrısı yapan bir ajan = 5+ saniye gecikme.

Önleme: Paralel Araç Yürütme, Önbellekleme, Daha Hızlı Modeller

# Parallel execution
import asyncio

async def parallel_agent(lead_id):
    lead = await get_lead_async(lead_id)
    
    # Call multiple tools in parallel
    enrichment, scoring = await asyncio.gather(
        enrich_lead_async(lead),
        score_lead_async(lead)
    )
    
    return (enrichment, scoring)

Daha hızlı modeller kullanın:

# Instead of GPT-4 (slower, more accurate)
# Use GPT-3.5-turbo (faster, still accurate enough)
model = "gpt-3.5-turbo"  # 200ms latency vs 500ms for GPT-4

Kurtarma: Zaman Aşımı, Kısmi Sonuçları Dön, Async İçin Kuyruğa Al

try:
    result = agent.run(timeout=5)  # 5 second timeout
    return result
except TimeoutError:
    # Return partial results
    return partial_result
    # Queue for async completion
    queue.enqueue(complete_agent, lead_id)

Ajan Performansını ve ROI’yi Ölçme

Takip Edilecek Temel Metrikler

Doğruluk (Doğru Kararların/Eylemlerin Yüzdesi)

Ajan çıktısını ground truth ile karşılaştırın (insan incelemesi, gerçek sonuçlar).

correct = 0
total = 100

for decision in agent_decisions:
    if decision == human_review[decision.id]:
        correct += 1

accuracy = correct / total * 100  # e.g., 94%

Gecikme (Görevi Tamamlama Süresi)

Girdiden çıktıya uçtan uca süreyi ölçün.

start = time.time()
result = agent.run(input_data)
latency = time.time() - start  # e.g., 8.5 seconds

Görev Başına Maliyet (API Çağrıları, Hesaplama, İnsan İncelemesi)

cost = (llm_api_calls * llm_cost) + (tool_calls * tool_cost) + (human_review_rate * hourly_rate)
# e.g., $0.03 per lead

Kullanıcı Memnuniyeti (Human-in-the-Loop İse)

Kullanıcılara anket: “Ajan kararlarından ne kadar memnunsunuz?”

Otomasyon Oranı (İnsan Müdahalesi Olmadan Tamamlanan Görevlerin Yüzdesi)

automated = tasks_completed_by_agent
total = all_tasks
automation_rate = automated / total * 100  # e.g., 87%

ROI Hesaplama

Başlangıç: Manuel Sürecin Maliyeti (İnsan Saati × Saatlik Ücret)

Manual lead qualification:
- 100 leads/month
- 5 minutes per lead
- 500 hours/month
- $20/hour = $10,000/month

Ajan Maliyeti: Altyapı + API Çağrıları + İnsan Denetimi

Agent-driven:
- 100 leads/month
- $0.03 per lead (API calls)
- $3 total API cost
- $500/month human review (10% escalation)
- $100/month infrastructure
Total: $603/month

Geri Ödeme Süresi: Ajan Maliyeti < Manuel Maliyet Olduğunda

Savings per month: $10,000 - $603 = $9,397
ROI: 1,557% (9,397 / 603)
Payback period: < 1 month (immediate)

Örnek: Lead Kalifikasyon Ajanı ROI’si

Manual process:
- 500 leads/month
- 5 min per lead = 2,500 hours = $50,000/month

Agent process:
- 500 leads/month
- $0.03 per lead = $15
- 5% escalation (25 leads) = $250 human time
- Infrastructure = $500
Total: $765/month

Savings: $50,000 - $765 = $49,235/month
ROI: 6,436%

Sürekli İyileştirme

Metrikleri Zaman İçinde İzleyin

# Track daily metrics
daily_metrics = {
    'accuracy': 0.94,
    'latency': 8.5,
    'cost_per_task': 0.03,
    'automation_rate': 0.87
}

Farklı Ajan Yapılandırmalarını A/B Testi Yapın

# Test 1: GPT-4 (more accurate, slower)
# Test 2: GPT-3.5-turbo (faster, slightly less accurate)

# Measure: accuracy, latency, cost
# Choose based on your priorities

Doğruluğu Artırmak İçin Geri Bildirimi Dahil Edin

# Collect human feedback on agent mistakes
feedback = db.get_feedback()

# Retrain agent (adjust prompts, add examples)
agent.retrain(feedback)

# Measure: accuracy improves from 94% to 96%

Başarılı Ajanları Ölçeklendirin, Düşük Performanslıları Emekliye Ayırın

ROI’yi izleyin. Bir ajan değer sağlamıyorsa, emekliye ayırın. Başarılı ajanları diğer ekiplere ölçeklendirin.

Sıkça Sorulan Sorular

SSS bölümü frontmatter’dan otomatik olarak oluşturulur ve aşağıda görünür.

{{ cta-dark-panel heading=“Karmaşıklık Olmadan Ajan Oluşturun” description=“FlowHunt’ın yerel ajan platformu, araç entegrasyonu, hata yönetimi ve izlemeyi halleder. Haftalar değil, dakikalar içinde otonom iş akışları oluşturmaya başlayın.” ctaPrimaryText=“FlowHunt’ı Ücretsiz Deneyin” ctaPrimaryURL=“https://app.flowhunt.io/sign-in" ctaSecondaryText=“Demo Rezervasyonu” ctaSecondaryURL=“https://www.flowhunt.io/demo/" gradientStartColor="#7c3aed” gradientEndColor="#ec4899” gradientId=“cta-ai-agents” }}