Strands Agentları ile AI Ajanları Oluşturma: Basit Kılavuz

Strands Agents framework’ünü kullanarak yapay zeka ajanları geliştirmeye başlamak ister misiniz? Bu rehber, başlangıçtan ileri seviyeye, Strands Agents ile akıllı sistemleri kolayca inşa etmenin temel adımlarını ve pratik ipuçlarını sunuyor. Gelin, otomasyon ve akıllı karar alma yeteneklerini projelerinize nasıl dahil edeceğinizi birlikte keşfedelim.

Günümüzde teknolojinin hızla ilerlemesiyle birlikte, tekrarlayan görevleri otomatikleştirmek, karmaşık verileri analiz etmek ve hatta otonom kararlar almak, işletmeler ve bireyler için kritik bir hale gelmiştir. Peki, bu noktada yapay zeka ajanları devreye girerek hayatımızı nasıl kolaylaştırabilir? Gündelik işlerimizden kurumsal süreçlere kadar pek çok alanda, insan müdahalesini azaltarak verimliliği artıran ve hata oranını düşüren akıllı sistemlere ihtiyaç duyuyoruz. İşte tam da bu noktada, Strands Agents gibi framework’ler, yapay zeka (AI) ajanları geliştirmeyi daha erişilebilir ve yönetilebilir kılıyor.

Yapay zeka ajanları, belirli bir ortamda sensörler aracılığıyla algılayıp, eyleyiciler aracılığıyla hareket eden, hedeflerine ulaşmak için akıl yürütme ve öğrenme yeteneğine sahip yazılım varlıklarıdır. Bu ajanlar, en basit haliyle bir bilgisayar programından çok daha fazlasıdır; onlar, tıpkı insan gibi çevresini gözlemleyebilir, bu gözlemlerden anlam çıkarabilir ve belirli bir amaç doğrultusunda adımlar atabilirler. Örneğin, bir sanal asistan, kullanıcı komutlarını algılayan bir ajandır; bir akıllı termostat, ortam sıcaklığını algılayıp ısıtma/soğutma sistemini kontrol eden bir ajandır. Bu tür ajanlar, modern dünyada otomasyonun ve akıllı sistemlerin temel taşlarını oluşturmaktadır.

Strands Agents, bu karmaşık yapay zeka ajanlarını oluşturma sürecini basitleştirmeyi hedefleyen açık kaynaklı bir Python framework’üdür. Geleneksel AI geliştirme süreçleri genellikle yüksek düzeyde programlama bilgisi ve karmaşık algoritmalar gerektirirken, Strands Agents, modüler yapısı ve kullanıcı dostu arayüzü ile bu bariyerleri ortadan kaldırır. Bu sayede, hem deneyimli geliştiriciler hem de AI alanına yeni adım atanlar, hızla prototip oluşturabilir ve işlevsel ajanlar geliştirebilir. Framework, ajanın çevresini algılamasını sağlayan “sensörler” ve ajanın çevresinde değişiklik yapmasını sağlayan “eyleyiciler” gibi temel bileşenler üzerine kurulmuştur. Bu mimari, ajanların davranışlarını net bir şekilde tanımlamanıza ve yönetmenize olanak tanır.

Diğer AI framework’lerinden farklı olarak Strands Agents, genellikle daha çok “low-code” veya “no-code” yaklaşımına yakın bir esneklik sunar. Bu, özellikle hızlı geliştirme (rapid prototyping) gerektiren projelerde büyük bir avantajdır. Modüler yapısı sayesinde, farklı görevler için tasarlanmış sensör ve eyleyicileri kolayca bir araya getirebilir, ajanın davranış döngüsünü sezgisel bir şekilde kurgulayabilirsiniz. Bu sayede, “bir web sitesindeki fiyatları takip et”, “belirli anahtar kelimeler içeren e-postaları filtrele” veya “hava durumu verilerine göre akıllı ev sistemini ayarla” gibi çok çeşitli görevleri yerine getirecek ajanlar oluşturmak mümkün hale gelir. Strands Agents, yapay zeka dünyasına adım atmak isteyen herkes için güçlü ve erişilebilir bir başlangıç noktası sunar. Özellikle küçük ve orta ölçekli otomasyon projelerinde sağladığı hız ve esneklik ile dikkat çekmektedir. Bu framework ile geliştirilen ajanlar, veri toplama, iş akışı otomasyonu, proaktif uyarı sistemleri ve daha birçok alanda somut faydalar sağlayabilir.

Strands Agents ile İlk Yapay Zeka Ajanınızı Nasıl Oluşturursunuz?

Yapay zeka ajanlarını inşa etme süreci kulağa karmaşık gelse de, Strands Agents framework’ü ile bu süreç oldukça basitleşir. Bu bölümde, ilk ajanınızı adım adım nasıl kuracağınızı ve temel bileşenlerini nasıl anlayacağınızı öğreneceğiz. Başlamadan önce, ajanın ne olduğunu ve nasıl çalıştığını temel düzeyde kavramak önemlidir. Bir ajan, temel olarak bir döngü içinde çalışır: çevresini algılar (sensörler aracılığıyla), bu algılara göre bir karar verir (mantık), ve ardından bir eylemde bulunur (eyleyiciler aracılığıyla). Bu döngü sürekli tekrarlanır ve ajanın akıllı davranışını oluşturur.

Strands Agents Ortamının Kurulumu

Strands Agents ile çalışmaya başlamak için öncelikle bilgisayarınızda Python kurulu olması gerekmektedir. Python 3.7 veya üzeri bir sürüm önerilir. Kurulumdan sonra, Strands Agents kütüphanesini pip paket yöneticisi aracılığıyla kolayca yükleyebilirsiniz.

pip install strands-agents

Bu komut, Strands Agents kütüphanesini ve bağımlılıklarını sisteminize kuracaktır. Kurulum tamamlandıktan sonra, ilk basit "Merhaba Dünya" ajanı örneğimizi oluşturmaya hazırız.

Basit Bir "Merhaba Dünya" Ajanı Örneği:

Aşağıdaki kod bloğu, belirli aralıklarla konsola "Merhaba, ben bir Strands Ajanıyım!" mesajını yazdıran basit bir ajan oluşturur.

from strands_agents import Agent, Sensor, Action
import time

# Bir sensör tanımlayalım: Her zaman True döndüren basit bir sensör
class AlwaysTrueSensor(Sensor):
    def sense(self):
        # Bu sensör her çalıştığında konsola bir mesaj yazar ve True döndürür.
        print("Sensör algılıyor...")
        return True

# Bir eylem tanımlayalım: Konsola mesaj yazan bir eylem
class GreetingAction(Action):
    def execute(self, data):
        if data: # Sensörden True geldiyse
            print("Merhaba, ben bir Strands Ajanıyım!")
        else:
            print("Hiçbir şey algılanmadı, eylem tetiklenmedi.")

# Ajanımızı oluşturalım
def create_greeting_agent():
    agent = Agent(name="GreetingAgent")
    
    # Sensörü ajana ekleyelim
    agent.add_sensor("always_true", AlwaysTrueSensor())
    
    # Eylemi ajana ekleyelim
    agent.add_action("greet", GreetingAction())
    
    # Ajanın davranış döngüsünü tanımlayalım
    # Sensör "always_true" True döndürdüğünde "greet" eylemini tetikle
    agent.add_behavior("always_true", "greet")
    
    return agent

# Ajanı çalıştıralım
if __name__ == "__main__":
    my_agent = create_greeting_agent()
    print("GreetingAgent başlatılıyor. Çıkmak için Ctrl+C tuşlarına basın.")
    try:
        my_agent.run(interval=3) # Ajanı 3 saniyede bir çalıştır
    except KeyboardInterrupt:
        print("\nGreetingAgent durduruldu.")

Bu örnekte gördüğünüz gibi, bir ajan; sensörler, eylemler ve davranışlar olmak üzere üç ana bileşenden oluşur. AlwaysTrueSensor her zaman True değeri döndüren bir sensörken, GreetingAction bu True değeri aldığında belirli bir mesajı yazdıran bir eylemdir. agent.add_behavior("always_true", "greet") satırı ise sensör ile eylem arasındaki ilişkiyi, yani ajanın "davranışını" tanımlar. Bu sayede, ajanımız basit bir döngü içinde sürekli olarak merhaba mesajını vermeye devam eder.

Ajanın Anatomisi: Sensörler ve Eyleyiciler

Strands Agents'ın gücü, ajanların ortamlarıyla etkileşim kurmasını sağlayan modüler sensör ve eyleyici yapısında yatar. Bu bileşenler, ajanın gözleri ve elleri gibidir.

Sensörler (Sensors): Ajanın çevreden veri toplamasını sağlayan birimlerdir. Bir sensör, belirli bir kaynaktan bilgi alır ve bu bilgiyi ajanın işleyebileceği bir formata dönüştürür. sense() metodu, sensörün veri toplama mantığını içerir.
Örnek sensör türleri:
* Zaman Sensörü: Belirli zaman aralıklarında tetiklenir veya günün saatini kontrol eder.
* Dosya Sistemi Sensörü: Bir dosyadaki değişiklikleri veya yeni dosyaları algılar.
* API Sensörü: Harici bir web servisine (API) istek gönderip yanıtını işler.
* Veritabanı Sensörü: Bir veritabanındaki kayıtları sorgular ve sonuçları döndürür.

Eyleyiciler (Actions): Ajanın çevrede bir değişiklik yapmasını veya belirli bir görevi yerine getirmesini sağlayan birimlerdir. execute() metodu, eyleyicinin gerçekleştireceği iş mantığını içerir. Bu metot, genellikle sensörden gelen veriyi (veya ajanın karar mekanizmasından gelen çıktıyı) girdi olarak alır.
Örnek eyleyici türleri:
* Dosya Yazma Eyleyicisi: Toplanan veriyi bir dosyaya kaydeder.
* E-posta Gönderme Eyleyicisi: Belirli koşullar altında bir e-posta gönderir.
* API Çağırma Eyleyicisi: Başka bir servise (örneğin, bir SMS ağ geçidine) istek göndererek bir işlemi tetikler.
* Veritabanı Eyleyicisi: Veritabanına veri ekler, günceller veya siler.

Aşağıdaki örnekte, bir dosya içeriğini okuyan bir sensör ve bu içeriği başka bir dosyaya yazan bir eyleyici görebilirsiniz:

from strands_agents import Agent, Sensor, Action
import os

class FileContentSensor(Sensor):
    def __init__(self, filepath):
        self.filepath = filepath
        self.last_content = None

    def sense(self):
        if not os.path.exists(self.filepath):
            print(f"Uyarı: Dosya '{self.filepath}' bulunamadı.")
            return None
        with open(self.filepath, 'r', encoding='utf-8') as f:
            current_content = f.read()
            if current_content != self.last_content:
                self.last_content = current_content
                print(f"Yeni dosya içeriği algılandı: {current_content[:50]}...")
                return current_content
            else:
                return None # İçerik değişmediyse None döndür

class FileWriterAction(Action):
    def __init__(self, output_filepath):
        self.output_filepath = output_filepath

    def execute(self, data):
        if data:
            with open(self.output_filepath, 'a', encoding='utf-8') as f:
                f.write(f"\n--- Yeni İçerik ({time.strftime('%Y-%m-%d %H:%M:%S')}) ---\n")
                f.write(data)
            print(f"İçerik '{self.output_filepath}' dosyasına yazıldı.")
        else:
            print("Yazılacak veri bulunamadı.")

def create_file_agent(input_file, output_file):
    agent = Agent(name="FileMonitorAgent")
    agent.add_sensor("file_monitor", FileContentSensor(input_file))
    agent.add_action("file_writer", FileWriterAction(output_file))
    
    # Eğer sensör bir veri döndürürse (None değilse), eylemi tetikle
    agent.add_behavior("file_monitor", "file_writer", lambda data: data is not None)
    
    return agent

if __name__ == "__main__":
    input_filename = "input.txt"
    output_filename = "output.log"
    
    # Test için input.txt dosyasını oluşturalım
    with open(input_filename, 'w', encoding='utf-8') as f:
        f.write("İlk satır.\n")

    my_file_agent = create_file_agent(input_filename, output_filename)
    print(f"FileMonitorAgent başlatılıyor. '{input_filename}' dosyasını izleyecek.")
    print("Çıkmak için Ctrl+C tuşlarına basın.")
    
    try:
        # Ajanı 5 saniyede bir çalıştır
        # Bu sırada input.txt dosyasını manuel olarak değiştirerek ajanın tepkisini gözlemleyebilirsiniz.
        my_file_agent.run(interval=5) 
    except KeyboardInterrupt:
        print("\nFileMonitorAgent durduruldu.")
    finally:
        # Test dosyalarını temizleyelim
        if os.path.exists(input_filename):
            os.remove(input_filename)
        if os.path.exists(output_filename):
            os.remove(output_filename)

Bu örnek, Strands Agents'ın ne kadar esnek olduğunu göstermektedir. Ajan, input.txt dosyasındaki değişiklikleri algılar ve yeni içeriği output.log dosyasına ekler. add_behavior metodunda kullanılan lambda data: data is not None ifadesi, sensörden gelen verinin None olmaması durumunda eylemin tetiklenmesini sağlayan basit bir koşuldur. Bu tür koşullarla ajanın karar alma mantığını şekillendirebiliriz.

Gerçek Dünya Senaryolarında Strands Ajanları: Vaka Analizleri

Strands Agents'ın esnek yapısı, onu birçok gerçek dünya problemini çözmek için ideal bir araç haline getirir. İşletmelerin süreçlerini otomatikleştirmekten kişisel asistanlara kadar geniş bir yelpazede uygulama alanı bulabilir. Bu bölümde, Strands Agents ile geliştirilebilecek iki pratik senaryoyu ve bunların nasıl yapılandırılabileceğini inceleyeceğiz. Bu vaka analizleri, Strands Agents'ın sadece basit görevler için değil, aynı zamanda daha karmaşık iş akışlarını yönetmek için de kullanılabileceğini gösterecektir.

E-ticaret İçin Akıllı Fiyat Takip Ajanı

E-ticaret sektörü, dinamik fiyatlandırma stratejileri ve yoğun rekabet nedeniyle sürekli takibin gerekli olduğu bir alandır. Rakiplerin ürün fiyatlarını izlemek, kendi fiyatlandırma stratejinizi optimize etmek için kritik öneme sahiptir. Strands Agents ile basit ama etkili bir fiyat takip ajanı oluşturabiliriz.

Senaryo: Bir e-ticaret şirketi, anahtar ürünlerinin rakiplerindeki fiyat değişikliklerini otomatik olarak takip etmek ve bu bilgiyi bir veritabanına kaydetmek istiyor. Fiyat düşüşlerinde yöneticilere bildirim gönderilmesi hedefleniyor.

Ajanın İşleyişi:

1. Web Scraping Sensörü: Belirli rakip e-ticaret sitelerindeki ürün sayfalarını düzenli aralıklarla ziyaret eder. Ürünün adını, mevcut fiyatını ve stok durumunu (görsel betimleme: bir botun web sitesini ziyaret edip, ürün kartlarındaki fiyat etiketlerini okuduğunu hayal edin) BeautifulSoup veya Scrapy gibi kütüphaneler kullanarak ayrıştırır. Bu sensör, yeni fiyat veya stok değişikliği algıladığında ilgili veriyi döndürür.
2. Veritabanı Eyleyicisi: Sensörden gelen fiyat ve stok bilgilerini (ürün ID, rakip adı, tarih, fiyat, stok durumu gibi) bir SQL veritabanına (örneğin PostgreSQL veya SQLite) kaydeder.
3. Fiyat Karşılaştırma ve Bildirim Davranışı: Yeni algılanan fiyat, ajanın hafızasında tuttuğu son fiyatla karşılaştırılır. Eğer fiyatta belirli bir düşüş (örneğin %5 veya daha fazla) tespit edilirse, ajanın bir EmailSenderAction eyleyicisini tetiklemesi sağlanır.
4. E-posta Gönderme Eyleyicisi: Önceden tanımlanmış bir e-posta adresine, fiyat düşüşünü ve ilgili ürün detaylarını içeren bir bildirim e-postası gönderir.

Basitleştirilmiş Kod Akışı (Pseudocode):

# ... imports ...
from strands_agents import Agent, Sensor, Action
import requests
from bs4 import BeautifulSoup
import sqlite3
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

# 1. Web Scraping Sensörü
class PriceScraperSensor(Sensor):
    def __init__(self, product_url, product_name):
        self.product_url = product_url
        self.product_name = product_name
        self.last_price = None # Ajanın hafızası için son fiyatı tutar
        print(f"Sensör oluşturuldu: {self.product_name} için {self.product_url}")

    def sense(self):
        try:
            response = requests.get(self.product_url)
            soup = BeautifulSoup(response.content, 'html.parser')
            
            # Bu kısım web sitesinin HTML yapısına göre özelleştirilmelidir!
            # Örnek: Fiyatı içeren bir div veya span etiketi bulalım
            price_tag = soup.find('span', class_='price-value') 
            if not price_tag:
                price_tag = soup.find('div', class_='product-price') # Başka bir olası etiket
            
            if price_tag:
                current_price_str = price_tag.text.strip().replace(',', '.').replace('TL', '').strip()
                current_price = float(current_price_str)
                
                if self.last_price is None or current_price != self.last_price:
                    old_price = self.last_price
                    self.last_price = current_price
                    print(f"Fiyat değişimi algılandı: {self.product_name} - Önceki: {old_price if old_price else 'N/A'}, Yeni: {current_price}")
                    return {"product_name": self.product_name, "price": current_price, "old_price": old_price}
            
            print(f"Fiyat değişmedi veya bulunamadı: {self.product_name}")
            return None # Fiyat değişmediyse veya bulunamadıysa None döndür

        except Exception as e:
            print(f"Hata oluştu ({self.product_name}): {e}")
            return None

# 2. Veritabanı Eyleyicisi
class DatabaseLoggerAction(Action):
    def __init__(self, db_name="price_tracking.db"):
        self.conn = sqlite3.connect(db_name)
        self.cursor = self.conn.cursor()
        self.cursor.execute('''
            CREATE TABLE IF NOT EXISTS prices (
                id INTEGER PRIMARY KEY,
                product_name TEXT,
                price REAL,
                old_price REAL,
                timestamp TEXT
            )
        ''')
        self.conn.commit()
        print(f"Veritabanı eyleyicisi başlatıldı: {db_name}")

    def execute(self, data):
        if data:
            product_name = data.get("product_name")
            price = data.get("price")
            old_price = data.get("old_price")
            timestamp = time.strftime('%Y-%m-%d %H:%M:%S')
            self.cursor.execute("INSERT INTO prices (product_name, price, old_price, timestamp) VALUES (?, ?, ?, ?)",
                                (product_name, price, old_price, timestamp))
            self.conn.commit()
            print(f"Fiyat {product_name} ({price} TL) veritabanına kaydedildi.")
        else:
            print("Veritabanına kaydedilecek veri yok.")

# 3. E-posta Gönderme Eyleyicisi
class EmailSenderAction(Action):
    def __init__(self, sender_email, sender_password, receiver_email):
        self.sender_email = sender_email
        self.sender_password = sender_password
        self.receiver_email = receiver_email
        print(f"E-posta eyleyicisi başlatıldı: Gönderen {sender_email}, Alıcı {receiver_email}")

    def execute(self, data):
        if data and data.get("price_drop"):
            product_name = data.get("product_name")
            current_price = data.get("price")
            old_price = data.get("old_price")
            drop_percentage = data.get("drop_percentage")

            msg = MIMEMultipart()
            msg['From'] = self.sender_email
            msg['To'] = self.receiver_email
            msg['Subject'] = f"Fiyat Düşüşü: {product_name}!"

            body = f"""
            Merhaba,
            
            {product_name} ürününün fiyatında önemli bir düşüş tespit edildi:
            
            Önceki Fiyat: {old_price} TL
            Yeni Fiyat: {current_price} TL
            Düşüş Oranı: %{drop_percentage:.2f}
            
            Ürünü kontrol etmek için: {data.get("product_url")}
            
            Saygılarımızla,
            Fiyat Takip Ajanınız
            """
            msg.attach(MIMEText(body, 'plain'))

            try:
                # SSL/TLS şifrelemesi ile SMTP sunucusuna bağlanın
                server = smtplib.SMTP_SSL('smtp.gmail.com', 465) 
                server.login(self.sender_email, self.sender_password)
                server.send_message(msg)
                server.quit()
                print(f"Fiyat düşüşü bildirimi '{self.receiver_email}' adresine gönderildi.")
            except Exception as e:
                print(f"E-posta gönderme hatası: {e}")
        else:
            print("E-posta gönderilecek veri bulunamadı veya fiyat düşüşü yok.")

# Ajanı Oluşturma Fonksiyonu
def create_price_tracker_agent(product_url, product_name, sender_email, sender_password, receiver_email):
    agent = Agent(name=f"PriceTracker_{product_name.replace(' ', '')}")

    # Sensörleri ve Eyleyicileri ekle
    price_scraper = PriceScraperSensor(product_url, product_name)
    db_logger = DatabaseLoggerAction()
    email_sender = EmailSenderAction(sender_email, sender_password, receiver_email)
    
    agent.add_sensor("price_scraper", price_scraper)
    agent.add_action("db_logger", db_logger)
    agent.add_action("email_sender", email_sender)

    # Davranışları tanımla
    def price_change_logic(data):
        if data:
            # Veritabanına kaydetme eylemini her fiyat değişikliğinde tetikle
            agent.trigger_action("db_logger", data) 

            # Fiyat düşüşü kontrolü
            current_price = data.get("price")
            old_price = data.get("old_price")
            
            if old_price and current_price < old_price:
                drop_percentage = ((old_price - current_price) / old_price) * 100
                if drop_percentage >= 5: # %5 veya üzeri düşüşte bildirim gönder
                    print(f"Önemli fiyat düşüşü algılandı: {product_name} - %{drop_percentage:.2f}")
                    email_data = {
                        "price_drop": True,
                        "product_name": product_name,
                        "price": current_price,
                        "old_price": old_price,
                        "drop_percentage": drop_percentage,
                        "product_url": product_url
                    }
                    agent.trigger_action("email_sender", email_data)
        return False # Sensörün çıktısı direkt eylemi tetiklemesin, içerideki mantık tetiklesin

    # Sensör tetiklendiğinde price_change_logic fonksiyonunu çalıştır
    agent.add_behavior("price_scraper", "price_change_logic", price_change_logic)
    
    return agent

# --- Ajanı çalıştırmak için örnek main bloğu ---
if __name__ == "__main__":
    # Gerçek URL ve e-posta bilgilerinizi buraya girmeniz gerekmektedir!
    # Bu örnek sadece pseudocode olup, çalıştırılmadan önce detaylı uyarlama gerektirir.
    # Dummy verilerle test edilebilir.
    
    # Not: E-posta göndermek için Gmail kullanıyorsanız, uygulama şifresi oluşturmanız gerekebilir.
    # https://support.google.com/accounts/answer/185833?hl=tr
    SENDER_EMAIL = "your_email@gmail.com"
    SENDER_PASSWORD = "your_app_password" # Uygulama şifresi
    RECEIVER_EMAIL = "recipient_email@example.com"
    TARGET_PRODUCT_URL = "https://www.example.com/product/123" # Gerçek bir ürün URL'si
    TARGET_PRODUCT_NAME = "Akıllı Telefon X"

    print("Lütfen gerçek e-posta ve ürün URL'si bilgilerini güncelleyin.")

    # my_price_agent = create_price_tracker_agent(
    #     TARGET_PRODUCT_URL, 
    #     TARGET_PRODUCT_NAME,
    #     SENDER_EMAIL, 
    #     SENDER_PASSWORD, 
    #     RECEIVER_EMAIL
    # )
    # try:
    #     my_price_agent.run(interval=60 * 60) # Her saat başı çalıştır
    # except KeyboardInterrupt:
    #     print("\nPriceTrackerAgent durduruldu.")
    # finally:
    #     # Veritabanı bağlantısını kapat
    #     if hasattr(my_price_agent.actions.get("db_logger"), 'conn'):
    #         my_price_agent.actions.get("db_logger").conn.close()
    
    # Basit bir örnek için:
    print("Web scraping sensörünün çalışması için gerçek bir web sitesine ihtiyacımız var.")
    print("Örnek olarak, bir test sensörü ve loglama eyleyicisi ile ajanı yapılandıralım.")
    
    # TEST SENARYOSU: Web scraping ve e-posta gönderme adımları atlanarak sadece veri akışını gösteren bir ajan
    class MockPriceSensor(Sensor):
        def __init__(self):
            self.prices = [100.0, 95.0, 92.0, 92.0, 85.0, 80.0]
            self.index = 0
            self.last_price = None

        def sense(self):
            if self.index < len(self.prices):
                current_price = self.prices[self.index]
                self.index += 1
                
                if self.last_price is None or current_price != self.last_price:
                    old_price = self.last_price
                    self.last_price = current_price
                    return {"product_name": "Test Ürünü", "price": current_price, "old_price": old_price, "product_url": "http://test.com/urun"}
                return None
            return None

    mock_agent = Agent(name="MockPriceAgent")
    mock_agent.add_sensor("mock_price_sensor", MockPriceSensor())
    mock_agent.add_action("mock_db_logger", DatabaseLoggerAction(db_name="mock_price_tracking.db"))
    # mock_agent.add_action("mock_email_sender", EmailSenderAction(SENDER_EMAIL, SENDER_PASSWORD, RECEIVER_EMAIL)) # E-posta gönderme kapatıldı
    
    def mock_price_change_logic(data):
        if data:
            mock_agent.trigger_action("mock_db_logger", data)
            current_price = data.get("price")
            old_price = data.get("old_price")
            
            if old_price and current_price < old_price:
                drop_percentage = ((old_price - current_price) / old_price) * 100
                if drop_percentage >= 5:
                    print(f"MOCK: Önemli fiyat düşüşü (%{drop_percentage:.2f}) algılandı! {data.get('product_name')}: {current_price} TL (Önceki: {old_price} TL)")
                    # mock_agent.trigger_action("mock_email_sender", {**data, "price_drop": True, "drop_percentage": drop_percentage})
        return False

    mock_agent.add_behavior("mock_price_sensor", "mock_price_change_logic", mock_price_change_logic)
    
    print("\nMock Price Agent başlatılıyor. Test verileri ile çalışacak.")
    print("Çıkmak için Ctrl+C tuşlarına basın.")
    try:
        mock_agent.run(interval=2) # Her 2 saniyede bir çalıştır
    except KeyboardInterrupt:
        print("\nMock Price Agent durduruldu.")
    finally:
        if hasattr(mock_agent.actions.get("mock_db_logger"), 'conn'):
            mock_agent.actions.get("mock_db_logger").conn.close()
        # Test için oluşturulan db dosyasını sil
        if os.path.exists("mock_price_tracking.db"):
            os.remove("mock_price_tracking.db")

Bu senaryoda, Strands Agents'ın modülerliği ve davranış tanımlama yeteneği sayesinde, karmaşık bir iş akışı otomatize edilmiş olur. Web scraping, veritabanı işlemleri ve bildirim gönderme gibi farklı görevler ayrı ayrı sensör ve eyleyicilerle yönetilerek, ajanın bakımı ve genişletilmesi kolaylaşır.

Müşteri Desteği Otomasyon Ajanı

Müşteri desteği departmanları genellikle tekrarlayan sorularla boğuşur ve bu durum hem müşteri memnuniyetini düşürebilir hem de operasyonel maliyetleri artırabilir. Strands Agents, bu tür süreçleri otomatikleştirerek ekiplerin daha karmaşık sorunlara odaklanmasını sağlayabilir.

Senaryo: Bir yazılım şirketi, gelen destek e-postalarını otomatik olarak okuyup, sıkça sorulan sorulara (SSS) uygun yanıtları göndermek ve daha karmaşık talepleri ilgili departmanlara yönlendirmek istiyor.

Ajanın İşleyişi:

1. E-posta Okuma Sensörü: Belirli bir e-posta hesabını (IMAP kullanarak) düzenli olarak kontrol eder. Yeni gelen e-postaları okur, konu ve içerik bilgilerini ayrıştırır. Okunan e-postaları "işlendi" olarak işaretleyebilir.
2. Doğal Dil İşleme (NLP) Davranışı: E-posta içeriğini alır ve metin sınıflandırma (örneğin, spaCy veya nltk ile basit anahtar kelime eşleştirme) kullanarak e-postanın kategorisini belirler (ör: "şifre sıfırlama", "hesap aktivasyonu", "teknik sorun", "genel soru").
3. Yanıt Şablonu Eyleyicisi: Eğer e-posta bir SSS kategorisine giriyorsa, önceden tanımlanmış bir yanıt şablonunu kullanır ve otomatik bir yanıt e-postası oluşturur. Bu eylem, EmailSenderAction gibi bir e-posta gönderme mekanizmasını tetikler.
4. Yönlendirme Eyleyicisi: Eğer e-posta karmaşık bir teknik sorunsa veya SSS kategorisine girmiyorsa, ilgili departmanın e-posta adresine (örneğin support-level2@company.com) orijinal e-postayı veya özetini yönlendirir.

Mobil Uyumlu HTML/CSS Yapısı (Örnek - Ajanın Rapor Çıkışları İçin):

Eğer ajan, web tabanlı bir arayüz veya rapor paneli üzerinden izleniyorsa, bu arayüzün mobil uyumlu olması önemlidir. Aşağıdaki CSS kodu, ajanın ürettiği raporların veya bildirimlerin mobil cihazlarda düzgün görünmesini sağlamak için kullanılabilir.

/* Rapor veya bildirim çıktısı için genel stiller */
.report-container {
    padding: 20px;
    border: 1px solid #ddd;
    border-radius: 8px;
    background-color: #fff;
    margin-bottom: 20px;
}
.report-header {
    font-size: 1.5em;
    color: #3498db;
    margin-bottom: 15px;
}
.report-item {
    margin-bottom: 10px;
    padding: 10px;
    border-left: 4px solid #1abc9c;
    background-color: #f8f8f8;
}
.report-item strong {
    color: #2c3e50;
}

/* Mobil cihazlar için responsive ayarlar */
@media (max-width: 600px) {
    .report-container {
        padding: 10px;
        margin: 10px;
    }
    .report-header {
        font-size: 1.2em;
    }
    .report-item {
        font-size: 0.9em;
        padding: 8px;
    }
}

Bu CSS, ajanın ürettiği raporları daha okunaklı hale getirir ve küçük ekranlarda dahi bilgilerin düzgün bir şekilde görüntülenmesini sağlar. Bir e-posta gönderen ajan, HTML tabanlı e-postalar için de benzer responsive tasarım prensiplerini uygulayarak, alıcıların e-postayı mobil cihazlarında rahatça okumasını sağlayabilir.

Performansı Optimize Etme ve Strands Ajanlarını İleri Düzeyde Kullanma

Strands Agents ile temel ajanlar oluşturmak kolay olsa da, ajanlarınızı gerçek dünya senaryolarında daha verimli, güvenli ve ölçeklenebilir hale getirmek için bazı ileri düzey tekniklere ihtiyaç duyulur. Bu bölümde, ajanın performansını artırma, davranışlarını daha sofistike hale getirme ve çoklu ajan sistemleri gibi konulara odaklanacağız.

Ajan Davranışlarını Geliştirme ve Modülerlik

Bir ajanın performansı, sadece doğru sensör ve eyleyicilere sahip olmasıyla değil, aynı zamanda bu bileşenleri ne kadar etkin bir şekilde kullandığıyla da ilgilidir.

Ajan Durum Yönetimi ve Hafıza Kullanımı: Ajanlar genellikle önceki eylemlerinden veya algılamalarından edindikleri bilgilere ihtiyaç duyarlar. Strands Agents'ta ajanın durumunu yönetmek için, sensör veya eyleyici sınıflarınızın __init__ metodunda self değişkenleri tanımlayarak durumu saklayabilirsiniz (yukarıdaki PriceScraperSensor örneğindeki self.last_price gibi). Daha karmaşık durumlar için, ajanın bir veritabanı, Redis gibi bir anahtar-değer deposu veya hatta dosya sistemi aracılığıyla kalıcı bir hafızaya sahip olmasını sağlayabilirsiniz. Bu, ajanın her çalıştığında sıfırdan başlamamasını ve öğrenilmiş bilgileri korumasını sağlar.

Birden Fazla Ajanın Birlikte Çalışması (Multi-Agent Systems): Tek bir ajanın yerine, farklı görevlere odaklanmış birden fazla ajanı bir araya getirmek, karmaşık problemlerin çözümünde daha etkili olabilir. Örneğin, bir ajan web sitelerini tararken, başka bir ajan toplanan veriyi analiz edebilir ve üçüncü bir ajan bildirim gönderebilir. Strands Agents'ın modüler yapısı, bu tür çoklu ajan sistemlerini kurmayı kolaylaştırır. Ajanlar arası iletişimi, ortak bir veritabanı, mesaj kuyrukları (RabbitMQ, Kafka) veya basit dosya sistemleri üzerinden sağlayabilirsiniz. Her ajan kendi belirli sorumluluğunu yerine getirdiğinden, sistem daha esnek ve hata toleranslı hale gelir.

Hata Yönetimi ve Günlükleme (Logging): Her yazılımda olduğu gibi, ajanlar da beklenmeyen durumlarla karşılaşabilir. Sensörlerin API çağrıları başarısız olabilir, veritabanı bağlantıları kesilebilir veya eyleyiciler bir hata fırlatabilir. Bu durumlar için sağlam hata yönetimi mekanizmaları oluşturmak önemlidir:
* try-except blokları: Kritik kod parçalarını bu bloklar içine alarak, hataların ajanın tamamen çökmesini engellemesini sağlayın.
* Günlükleme (Logging): Python'ın logging modülü, ajanın çalışma zamanındaki olayları, uyarıları ve hataları kaydetmek için güçlü bir araçtır. Bu loglar, ajanın davranışını anlamanıza ve sorunları teşhis etmenize yardımcı olur.

import logging

# Loglama yapılandırması
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

class RobustAPISensor(Sensor):
    def __init__(self, api_url):
        self.api_url = api_url

    def sense(self):
        try:
            response = requests.get(self.api_url, timeout=10) # 10 saniye zaman aşımı
            response.raise_for_status() # HTTP hataları için istisna fırlat
            data = response.json()
            logger.info(f"API'den veri başarıyla alındı: {self.api_url}")
            return data
        except requests.exceptions.Timeout:
            logger.error(f"API isteği zaman aşımına uğradı: {self.api_url}")
            return None
        except requests.exceptions.RequestException as e:
            logger.error(f"API isteği hatası ({self.api_url}): {e}")
            return None
        except ValueError as e:
            logger.error(f"API yanıtı JSON formatında değil veya işlenemedi: {e}")
            return None

Bu örnek, bir API sensöründe zaman aşımı, ağ hataları ve JSON ayrıştırma hataları gibi farklı senaryoları nasıl ele alacağınızı gösterir.

Güvenlik ve Ölçeklenebilirlik İçin İpuçları

Ajanlarınızı üretime taşırken, güvenlik ve performans konuları büyük önem taşır.

API Anahtarlarının Güvenli Saklanması: Ajanlar genellikle harici servislerle etkileşim kurmak için API anahtarları veya kimlik bilgileri kullanır. Bu bilgileri doğrudan kod içine yazmak yerine, çevre değişkenleri (os.environ), .env dosyaları (python-dotenv kütüphanesi ile) veya özel bir sır yönetimi çözümü (HashiCorp Vault, AWS Secrets Manager gibi) kullanarak güvenli bir şekilde saklayın. Bu, kodunuzun dağıtılabilirliğini ve güvenliğini artırır.

Asenkron İşlemler ve Kuyruk Sistemleri Entegrasyonu: Bir ajanın yapması gereken bazı işlemler uzun sürebilir (örneğin, büyük bir dosyayı işlemek, karmaşık bir hesaplama yapmak). Eğer ajanın tüm döngüsü bu uzun işlemleri beklerse, diğer sensörlerin algılaması veya başka eylemlerin tetiklenmesi gecikebilir. Bu tür durumlarda, asenkron işlemler veya mesaj kuyrukları kullanmak akıllıca bir yaklaşımdır. Ajan, uzun süreli bir görevi bir mesaj kuyruğuna (örneğin Celery, RabbitMQ) bırakabilir ve görevin arka planda başka bir işçi (worker) tarafından işlenmesini sağlayabilir. Böylece ajanın ana döngüsü kesintiye uğramaz ve ajanın tepki süresi artar.

Performans İzleme ve Optimizasyon: Ajanlarınızın canlı ortamda nasıl performans gösterdiğini izlemek kritik öneme sahiptir.
* Metrik Toplama: Ajanın çalıştığı sıklık, sensörlerin veri toplama süresi, eyleyicilerin tamamlama süresi gibi metrikleri izleyin. Prometheus gibi araçlar ve Grafana gibi görselleştirme panoları bu verileri takip etmek için kullanılabilir.
* Kaynak Kullanımı: Ajanın CPU, bellek ve ağ kullanımını düzenli olarak kontrol edin. Beklenmeyen artışlar, bir bellek sızıntısı veya verimsiz bir işlem olduğunu gösterebilir.
* Profil Oluşturma (Profiling): Python'ın yerleşik cProfile modülü gibi araçlar, kodunuzun hangi kısımlarının en çok zaman aldığını belirlemenize yardımcı olabilir. Bu sayede optimizasyon çabalarınızı en verimli noktalara odaklayabilirsiniz.

Sonuç ve Sıkça Sorulan Sorular

Bu rehber boyunca, Strands Agents framework'ü ile yapay zeka ajanları geliştirmenin temel prensiplerini, adım adım kurulumunu ve gerçek dünya senaryolarında nasıl kullanılabileceğini keşfettik. Gördüğümüz gibi, Strands Agents, modüler yapısı, sezgisel davranış tanımlama mekanizmaları ve Python'ın gücü sayesinde, AI ajanları oluşturmayı hem yeni başlayanlar hem de deneyimli geliştiriciler için oldukça erişilebilir kılıyor. Basit otomasyon görevlerinden karmaşık karar alma sistemlerine kadar geniş bir yelpazede kullanılabilen bu framework, iş süreçlerini optimize etmek, verimliliği artırmak ve daha akıllı uygulamalar geliştirmek isteyen herkes için değerli bir araçtır.

Strands Agents, tekrarlayan manuel görevleri ortadan kaldırarak insan kaynağını daha yaratıcı ve stratejik işlere yönlendirme potansiyeli sunar. E-ticaretten müşteri hizmetlerine, veri analizinden sistem izlemeye kadar birçok alanda akıllı ajanlar tasarlayabilir ve dağıtabilirsiniz. Unutmayın ki, bir ajanın gücü, onun sensörlerinin ne kadar iyi algıladığı, eyleyicilerinin ne kadar etkili davrandığı ve davranış mantığının ne kadar akıllıca tasarlandığıyla doğru orantılıdır. Sürekli öğrenme ve iyileştirme, ajanlarınızın zamanla daha da akıllı hale gelmesini sağlayacaktır. Bu rehberin, Strands Agents dünyasına ilk adımınızı atmanız için size sağlam bir temel sunduğunu umuyoruz.

Sıkça Sorulan Sorular