LangChain & LangGraph ile Otonom AI Ajan Geliştirme Rehberi: Starbucks Agent

Yapay zeka teknolojileri hızla gelişirken, otonom ajanlar iş dünyasında devrim yaratma potansiyeli taşıyor. Bu makalede, LangChain ve LangGraph gibi güçlü araçları kullanarak kendi kendine karar verebilen bir AI ajanı nasıl geliştireceğinizi adım adım keşfedeceksiniz. Özellikle, LangChain ve LangGraph’ın temel kavramlarından başlayarak, Starbucks senaryosunda sipariş alıp işleyebilen gerçekçi bir otonom kahve ajanı oluşturma sürecine odaklanacağız.

Günümüzün rekabetçi iş dünyasında verimlilik ve otomasyon, şirketlerin ayakta kalması ve büyümesi için hayati önem taşıyor. İşte tam bu noktada Yapay Zeka (AI) ajanları devreye giriyor. Peki, bir AI ajanı tam olarak nedir ve işletmelere nasıl bir değer sunar? En basit tanımıyla, bir AI ajanı, belirli bir ortamda algılayabilen, bilgi işleyebilen ve hedeflerine ulaşmak için otonom kararlar alarak eylemler gerçekleştirebilen bir yazılım varlığıdır. Geleneksel otomasyon sistemlerinin aksine, AI ajanları daha karmaşık, öngörülemeyen senaryolarla başa çıkabilir ve hatta deneyimlerinden öğrenerek zamanla performanslarını artırabilirler.

Bu yetenekleri sayesinde AI ajanları, müşteri hizmetlerinden tedarik zinciri yönetimine, finansal analizlerden sağlık hizmetlerine kadar pek çok alanda dönüştürücü bir etki yaratma potansiyeline sahiptir. Örneğin, müşteri hizmetlerinde bir chatbotun çok ötesine geçerek, bir müşterinin karmaşık sorununu anlayabilen, ilgili departmanlarla iletişime geçebilen ve hatta kişiye özel çözümler üretebilen bir ajanı hayal edin. Bu, hem müşteri memnuniyetini artırır hem de operasyonel maliyetleri önemli ölçüde düşürür. Bir diğer örnek ise, piyasa verilerini sürekli analiz ederek alım-satım kararları verebilen finansal ajanlar veya hastanın semptomlarını değerlendirip olası teşhisler önerebilen medikal ajanlardır.

AI ajanlarının sağladığı temel avantajları birkaç maddede özetleyebiliriz:

• Otomasyon ve Verimlilik: Tekrarlayan, zaman alıcı görevleri otomatikleştirerek insan kaynaklarının daha stratejik işlere odaklanmasını sağlarlar. Böylece genel verimlilik artar.
• Sürekli Erişilebilirlik: 7/24 kesintisiz hizmet sunabilirler, bu da küresel operasyonlar ve farklı zaman dilimlerindeki müşteriler için büyük bir avantajdır.
• Karar Verme Yeteneği: Büyük veri kümelerini analiz ederek insan gözünden kaçabilecek içgörüler sunar ve daha bilinçli kararlar alınmasına yardımcı olurlar. Bazı durumlarda insan müdahalesi olmadan karar alıp uygulayabilirler.
• Ölçeklenebilirlik: İş yükü arttığında kolayca ölçeklendirilebilirler. İnsan ekibinin aksine, daha fazla ajanı devreye sokmak genellikle daha az maliyetli ve daha hızlıdır.
• Kişiselleştirme: Kullanıcı etkileşimlerini öğrenerek kişiye özel deneyimler sunabilir, bu da müşteri sadakatini ve satışları artırabilir.
• Hata Azaltma: İnsan hatası olasılığını azaltarak operasyonel süreçlerde tutarlılığı ve doğruluğu artırırlar.

Bu potansiyel, AI ajanlarını sadece bir teknoloji trendi olmaktan çıkarıp, şirketler için stratejik bir yatırım haline getiriyor. Gelecekte, her sektörde AI ajanlarının farklı rollerde karşımıza çıkması kaçınılmaz görünüyor. İşte bu yüzden, LangChain ve LangGraph gibi araçlarla AI ajanı geliştirme becerilerini edinmek, hem bireysel geliştiriciler hem de işletmeler için kritik bir yetkinlik haline gelmektedir.

Temel Taşlar: LangChain, LangGraph ve LLM’ler Neler Sunuyor?

Otonom AI ajanları geliştirirken karşımıza çıkan en güçlü ve esnek araçlardan ikisi LangChain ve LangGraph’tır. Bu iki kütüphane, Büyük Dil Modellerini (LLM’ler) kullanarak karmaşık etkileşimler ve çok adımlı görevler tasarlamamıza olanak tanır. Ancak başlamadan önce, bu teknolojilerin her birinin ne işe yaradığını ve neden bu kadar önemli olduklarını anlamamız gerekiyor.

Büyük Dil Modelleri (LLM’ler): Yapay Zekanın Kalbi

Her şeyin merkezinde Büyük Dil Modelleri (Large Language Models – LLM) yer alır. GPT-4, Claude, Llama gibi modeller, milyarlarca parametreye sahip olup devasa metin veri kümeleri üzerinde eğitilmişlerdir. Bu sayede, insan dilini anlama, metin üretme, çeviri yapma, özetleme ve hatta kod yazma gibi inanılmaz yeteneklere sahiptirler. Bir AI ajanı için LLM, beynin ta kendisidir; karar verme, düşünme ve iletişim kurma yeteneğini sağlar. Ancak, tek başına bir LLM, genellikle belirli bir görevi yerine getirmek için yeterli değildir. LLM’ler dünyayı sadece metin olarak bilir ve dış dünyayla etkileşime geçmek için araçlara ihtiyaç duyarlar. İşte burada LangChain ve LangGraph devreye girer.

LangChain: LLM Uygulamaları İçin Bir Çerçeve

LangChain, LLM’lerin gücünü kullanarak karmaşık uygulamalar geliştirmeyi kolaylaştıran popüler bir Python kütüphanesidir. Adından da anlaşılacağı gibi, “dil zincirleri” oluşturmamıza olanak tanır; yani, birden fazla LLM çağrısını, diğer araçları ve veri kaynaklarını bir araya getirerek sofistike iş akışları tasarlayabiliriz. LangChain’in sunduğu temel bileşenler şunlardır:

• Modeller (Models): Çeşitli LLM’lerle (OpenAI, Hugging Face vb.) entegrasyonu sağlar.
• Prompt’lar (Prompts): LLM’lere girdi olarak verilen metinleri yönetmek ve şablonlamak için araçlar sunar.
• Zincirler (Chains): Birden fazla LLM çağrısını veya başka bir işlemi ardışık olarak birleştirir. Örneğin, bir metni özetleyip ardından başka bir LLM’e gönderebilir.
• Ajanlar (Agents): Bir LLM’in hangi aracı ne zaman kullanacağına karar vermesini sağlayan yapıdır. Bu, ajanın “düşünmesini” ve dinamik olarak eylem planları oluşturmasını sağlar.
• Araçlar (Tools): LLM’lerin dış dünyayla etkileşime girmesini sağlayan fonksiyonlardır (örn. Google araması, API çağrısı, veritabanı sorgusu).
• Bellek (Memory): Ajanın önceki etkileşimlerini hatırlamasını sağlar, bu da daha tutarlı ve bağlamsal sohbetler için kritiktir.

LangChain, bu bileşenleri bir araya getirerek, bir LLM’in sadece metin üretmekle kalmayıp, aynı zamanda belirli bir amaca yönelik olarak hareket edebilmesini, bilgi toplayabilmesini ve aldığı kararlara göre aksiyon alabilmesini sağlar. Örneğin, bir e-ticaret ajanı LangChain ile ürün stoğunu kontrol etmek için bir veritabanı aracını kullanabilir ve ardından müşteriye bilgi vermek için bir LLM kullanabilir.

LangGraph: Ajanların Durum Yönetimi ve Çoklu Adımlı Karar Alma

LangChain, tek adımlı veya basit zincirleme görevler için harikayken, daha karmaşık ve döngüsel etkileşimler gerektiren otonom ajanlar için bazen yetersiz kalabilir. İşte bu noktada LangGraph devreye girer. LangGraph, LangChain’in üzerine inşa edilmiş, ajanları bir durum makinesi (state machine) veya yönlendirilmiş bir graf (directed graph) olarak modellemeyi sağlayan bir kütüphanedir. Bu, ajanların daha sofistike karar verme süreçlerine sahip olmasını, önceki eylemlerine veya gözlemlerine göre farklı yolları takip etmesini ve hatta kendi kendine düzeltmeler yapmasını sağlar.

LangGraph’ın ana avantajları şunlardır:

• Durum Yönetimi: Ajanın mevcut durumunu (örneğin, “sipariş alınıyor”, “ödeme bekleniyor”) tanımlayabilir ve bu durumu kolayca güncelleyebiliriz.
• Döngüler ve Şartlı Mantık: Bir görev tamamlanana kadar belirli adımları tekrarlayabilen (döngüler) veya belirli koşullara göre farklı adımlara geçiş yapabilen (şartlı mantık) akışlar oluşturabiliriz. Bu, hata düzeltme veya tekrar deneme mekanizmaları için idealdir.
• Çok Aşamalı Planlama: Ajanın karmaşık bir hedefi gerçekleştirmek için adım adım bir plan yapmasını ve bu planı uygulamada esneklik göstermesini sağlar.
• Şeffaflık: Ajanın karar verme sürecini ve hangi adımları izlediğini görsel olarak takip etmek daha kolaydır, bu da hata ayıklamayı ve geliştirmeyi basitleştirir.

Özetle, LangChain bir LLM’e dış dünyayla etkileşim kurma yeteneği verirken, LangGraph bu etkileşimleri daha yapılandırılmış, esnek ve akıllı bir şekilde yönetmeyi sağlar. Bir Starbucks ajanı örneğinde, LangChain menüye bakma veya sipariş alma gibi araçları sağlarken, LangGraph bu araçları ne zaman kullanacağını, bir hata olduğunda ne yapacağını veya müşteri siparişini değiştirdiğinde nasıl yeniden planlayacağını yönetecek iskeleti oluşturacaktır.

Otonom Starbucks Ajanı: Kavramsal Tasarım ve Mimari

Şimdi teoriden pratiğe geçelim ve “Otonom Starbucks Ajanı”mızı tasarlayalım. Amacımız, bir müşterinin Starbucks’ta kahve siparişini tam anlamıyla otonom bir şekilde alıp işleyebilecek bir AI ajanı oluşturmak. Bu ajan, müşterinin taleplerini anlayacak, menüyü kontrol edecek, siparişi doğrulayacak ve hatta ödeme sürecini simüle edecek yetenekte olmalı. Bu tür bir ajanı inşa etmek için nasıl bir mimari ve tasarım stratejisi izlememiz gerekiyor?

Ajanın Görevleri ve Hedefleri

Starbucks Ajanı’nın temel görevleri şunlardır:

1. Müşteri İletişimi: Müşteriden sipariş almak, sorularını yanıtlamak ve olası belirsizlikleri gidermek.
2. Menü Kontrolü: Müşterinin istediği ürünlerin menüde olup olmadığını ve fiyatlarını kontrol etmek.
3. Sipariş Oluşturma: Müşterinin isteklerine göre doğru siparişi oluşturmak (örn. “büyük boy latte, badem sütlü”).
4. Sipariş Doğrulama: Oluşturulan siparişi müşteriye teyit ettirmek.
5. Ödeme İşlemi (Simülasyon): Sipariş tutarını hesaplamak ve ödeme işlemini başlatmak/tamamlamak.
6. Hata Yönetimi: Eksik bilgi, menüde olmayan ürün veya ödeme hatası gibi durumlarda uygun şekilde tepki vermek.

Ajanın nihai hedefi, müşterinin sorunsuz ve keyifli bir sipariş deneyimi yaşamasını sağlamaktır.

Mimari Bileşenler: LLM, Araçlar ve Durum Yönetimi

Ajanımızı tasarlarken, LangChain ve LangGraph’ın sunduğu yetenekleri bir araya getireceğiz:

1. Büyük Dil Modeli (LLM): Ajanın “beyni” olarak görev yapacak. Müşteri girdisini anlayacak, karar verecek ve çıktılar üretecek. Örneğin, OpenAI’nin GPT-4 modeli tercih edilebilir.
2. Araçlar (Tools): LLM’in dış dünyayla etkileşime geçmesini sağlayacak spesifik fonksiyonlar. Bu senaryoda başlıca araçlar şunlar olabilir:
   • get_menu(item_name: str = None): Starbucks menüsünü sorgular. Belirli bir ürün istenirse detaylarını, istenmezse tüm menüyü döner.
   • calculate_order_total(order_details: dict): Verilen siparişin toplam tutarını hesaplar.
   • process_payment(amount: float): Ödeme işlemini simüle eder. Gerçek bir uygulamada Stripe veya başka bir ödeme geçidi entegre edilebilir.
   • confirm_order(order_id: str, customer_name: str): Siparişin sisteme kaydedildiğini simüle eder.

   Bu araçlar Python fonksiyonları olarak tanımlanacak ve LangChain’e tanıtılacak.

3. Ajan (Agent – LangChain): LLM’i ve tanımlanan araçları bir araya getiren ana karar mekanizması. Müşteri talebine göre hangi aracı kullanacağına karar verir.
4. Durum Grafiği (State Graph – LangGraph): Ajanın karmaşık iş akışını, döngülerini ve karar noktalarını yönetecek ana yapı. Bu, siparişin alınmasından ödemeye kadar olan tüm süreci yönetir ve olası hataları ele alır. Grafın temel düğümleri (nodes) müşteri girdisini işleme, menü sorgulama, sipariş doğrulama ve ödeme gibi aşamalar olabilirken, geçişler (edges) bu aşamalar arasındaki mantıksal akışı belirleyecektir.

Veri Yapıları ve Akış

Ajanın durumunu yönetmek için bir durum (state) yapısı tanımlamamız gerekecek. Bu durum, LLM ve araçlar arasında paylaşılan bilgiyi içerecektir. Örneğin:

from typing import TypedDict, List, Dict, Union

class AgentState(TypedDict):
    chat_history: List[str]  # Müşteri ve ajanın konuşma geçmişi
    current_order: Dict[str, Union[int, float]]  # Mevcut sipariş detayları (ürün, miktar, fiyat)
    order_total: float  # Toplam sipariş tutarı
    payment_status: str  # Ödeme durumu (bekliyor, başarılı, başarısız)
    user_query: str # Kullanıcının son girdisi
    menu_data: Dict # Menü bilgileri
    tools_output: str # Araçtan dönen son çıktı
    

Bu AgentState yapısı, ajanın her adımda neyi bilmesi gerektiğini ve hangi bilgileri aktarması gerektiğini gösterir. LangGraph, bu durumun düğümler arasında nasıl güncelleneceğini ve geçişlerin bu duruma göre nasıl tetikleneceğini yönetecektir. Örneğin, current_order boşsa, ajan "sipariş alma" modunda demektir. Eğer order_total hesaplanmışsa, "ödeme bekleme" moduna geçebilir.

Bu kavramsal tasarım, LangChain'in araç entegrasyonu ve LLM ile karar alma yeteneğini, LangGraph'ın ise bu kararları yapılandırılmış, çok adımlı bir süreçte yönetme gücüyle birleştirerek sağlam bir temel oluşturur. Böylece ajanın sadece basit soruları yanıtlamakla kalmayıp, karmaşık bir hizmet sürecini baştan sona yönetebilmesini sağlarız. Gelecek bölümde, bu tasarımı Python koduyla nasıl hayata geçireceğimizi detaylıca inceleyeceğiz.

Adım Adım Uygulama: Starbucks Ajanını Nasıl Kodlarız?

Şimdi teorik bilgileri pratiğe dökelim ve otonom Starbucks Ajanımızı kodlamaya başlayalım. Bu bölümde, gerekli kurulumlardan başlayarak, araçlarımızı tanımlamaya, LangChain ajanı oluşturmaya ve son olarak LangGraph ile karmaşık bir iş akışı tasarlamaya kadar her adımı detaylıca ele alacağız.

1. Gerekli Kütüphaneleri Kurma ve API Anahtarlarını Ayarlama

İlk adım, projemiz için gerekli Python kütüphanelerini kurmak ve OpenAI gibi bir LLM sağlayıcısının API anahtarını ayarlamaktır.

pip install langchain langchain-openai langgraph beautifulsoup4
    

Ardından, API anahtarınızı ortam değişkeni olarak ayarlayın veya doğrudan kod içinde tanımlayın (güvenlik açısından ortam değişkeni tercih edilir):

import os
from langchain_openai import ChatOpenAI

# Ortam değişkeninden API anahtarını alın
os.environ["OPENAI_API_KEY"] = "sizin_openai_api_anahtarınız" # Burayı kendi anahtarınızla değiştirin

# LLM modelini başlatın
llm = ChatOpenAI(model="gpt-4o", temperature=0)
    

2. Araçlarımızı Tanımlama

Ajanımızın dış dünyayla etkileşime geçmesini sağlayacak araçları (fonksiyonları) tanımlayalım. Bu araçlar, ajanın menüyü kontrol etmesi, sipariş tutarını hesaplaması ve ödeme işlemini simüle etmesi için kullanılacak.

from langchain.tools import tool

# Basit bir Starbucks menüsü (gerçekçi olması için biraz daha genişletilebilir)
STARBUCKS_MENU = {
    "latte": {"price": 10.0, "description": "Espresso, buhar sütü, köpük"},
    "cappuccino": {"price": 9.5, "description": "Espresso, buhar sütü, yoğun köpük"},
    "mocha": {"price": 11.0, "description": "Espresso, çikolata sosu, buhar sütü, krem şanti"},
    "americano": {"price": 8.0, "description": "Espresso, sıcak su"},
    "espresso": {"price": 7.0, "description": "Tek veya çift shot espresso"},
    "frappuccino": {"price": 12.0, "description": "Buzlu, karıştırılmış kahve içeceği"},
    "iced coffee": {"price": 8.5, "description": "Buzlu filtre kahve"},
    "croissant": {"price": 5.0, "description": "Tereyağlı kruvasan"},
    "muffin": {"price": 4.5, "description": "Çeşitli aromalarda muffin"},
}

@tool
def get_menu(item_name: str = None) -> str:
    """Starbucks menüsünü sorgular. Eğer 'item_name' belirtilirse o ürünün detaylarını döner.
    Belirtilmezse tüm menüdeki içecek ve yiyecekleri listeler."""
    if item_name:
        item = STARBUCKS_MENU.get(item_name.lower())
        if item:
            return f"{item_name.capitalize()}: Fiyatı {item['price']} TL. Açıklama: {item['description']}."
        else:
            return f"Üzgünüz, '{item_name}' menüde bulunmamaktadır."
    else:
        menu_items = "\n".join([f"- {name.capitalize()} ({details['price']} TL)" for name, details in STARBUCKS_MENU.items()])
        return f"Mevcut menü ürünlerimiz:\n{menu_items}"

@tool
def calculate_order_total(order_items: Dict[str, int]) -> float:
    """Verilen sipariş detaylarına göre toplam tutarı hesaplar.
    Örnek: {"latte": 2, "muffin": 1}"""
    total = 0.0
    for item, quantity in order_items.items():
        menu_item = STARBUCKS_MENU.get(item.lower())
        if not menu_item:
            raise ValueError(f"Menüde bulunmayan ürün: {item}")
        total += menu_item["price"] * quantity
    return total

@tool
def process_payment(amount: float) -> str:
    """Belirtilen tutarda ödeme işlemini simüle eder. Başarılı veya başarısız sonucunu döner."""
    # Gerçek bir uygulamada Stripe/ödeme geçidi API'si çağrılır.
    # Burada basit bir simülasyon yapalım.
    if amount > 0:
        return f"{amount} TL tutarındaki ödeme başarıyla alındı. Siparişiniz hazırlanıyor!"
    else:
        return "Ödeme işlemi başarısız. Lütfen tekrar deneyin."

# Tüm araçları bir listeye toplayalım
tools = [get_menu, calculate_order_total, process_payment]
    

3. LangChain Ajanını Oluşturma

Şimdi LLM'i ve araçlarımızı kullanarak bir LangChain ajanı oluşturalım. Bu ajan, gelen soruları anlayacak ve hangi aracı kullanacağına karar verecektir.

from langchain import hub
from langchain.agents import AgentExecutor, create_tool_calling_agent

# Ajan için prompt'u LangChain Hub'dan çekelim (veya kendimiz tanımlayabiliriz)
prompt = hub.pull("hwchase17/openai-tools-agent")

# Ajanı oluştur
agent = create_tool_calling_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
    

4. LangGraph ile Durum Yönetimi ve İş Akışı Tasarımı

En karmaşık kısım olan LangGraph ile durum makinesi (state machine) tasarımına geçiyoruz. Önce AgentState yapımızı hatırlayalım ve ardından grafımızı oluşturalım.

from langgraph.graph import StateGraph, END
from typing import TypedDict, List, Dict, Union, Annotated
from operator import add

# AgentState yapımızı tanımlayalım
class AgentState(TypedDict):
    chat_history: List[str]
    current_order: Dict[str, int] # Ürün adı: miktar
    order_total: Annotated[float, add] # Toplam tutar
    payment_status: str
    user_query: str
    tools_output: str

# Her bir düğüm (node) için fonksiyonlarımızı tanımlayalım
def run_agent(state: AgentState) -> AgentState:
    """Ajanın LLM'i kullanarak bir sonraki eylemi belirlediği düğüm."""
    print("---AGENT DÜĞÜMÜ ÇALIŞIYOR---")
    user_query = state["user_query"]
    # LangChain agent_executor'ı ile ajanın çalıştığı kısım
    response = agent_executor.invoke({"input": user_query, "chat_history": state["chat_history"]})
    
    # LLM'den gelen yanıtın bir araç çağrısı olup olmadığını kontrol et
    if "output" in response: # LLM direkt bir metin yanıtı verdi
        return {"chat_history": state["chat_history"] + [f"AI: {response['output']}"]}
    else: # LLM bir araç çağırması önerdi
        # LangGraph'ta araç çağrısı ve sonucunu manuel olarak yönetmek gerekiyor
        # Bu durumda, biz ajanın kendisinden dönen çıktıyı tools_output olarak saklayıp
        # bir sonraki düğümde işleyeceğiz.
        # Basitlik adına, burada LLM'in direkt bir yanıt verdiğini varsayalım
        # veya tools_output'u doğrudan çağrıdan sonra dolduralım.
        # Gerçek bir LangGraph ajanında, ajandan dönen "tool_calls" işlenmelidir.
        
        # Burası genellikle ajanın 'tool_calls' özelliğini inceleyip ilgili araçları manuel olarak çağırdığımız yerdir.
        # Şimdilik LangChain AgentExecutor'ın 'verbose=True' çıktılarından yararlanalım
        # veya basitleştirilmiş bir akış izleyelim.
        
        # Tam LangGraph entegrasyonu için, ajanın "planlama" çıktısını yakalayıp
        # sonraki düğümde "tool_execution" yapmalıyız.
        # Bu örnekte, agent_executor'ın doğrudan çıktı vermesini bekliyoruz.
        # Ancak daha sağlam bir yaklaşım için, 'create_react_agent' veya
        # 'create_tool_calling_agent' ile doğrudan 'tool_executor' kullanılabilir.
        
        # Basitlik adına, doğrudan agent_executor'dan dönen output'u işleyelim
        # veya eğer araç çağrısı yapıldıysa onu simüle edelim.
        # AgentExecutor genellikle output'u döndürür. Eğer bir tool kullandıysa, output tool'dan gelen sonuçtur.
        # Eğer tool kullanmadıysa, output LLM'in direkt yanıtıdır.
        if "output" in response:
            return {"chat_history": state["chat_history"] + [f"AI: {response['output']}"]}
        else: # Bu kısım LangChain AgentExecutor ile biraz farklı çalışabilir, genelde 'output' hep olur.
            return {"chat_history": state["chat_history"] + [f"AI: Anlayamadım, tekrar edebilir misiniz?"]}

def call_tool(state: AgentState) -> AgentState:
    """Ajanın bir araç çağırması gerektiğinde çalışan düğüm."""
    print("---ARAÇ ÇAĞRISI DÜĞÜMÜ ÇALIŞIYOR---")
    # Bu düğüm, 'run_agent' düğümünden gelen araç çağrısını alır ve yürütür.
    # Gerçek bir LangGraph ajanında, 'run_agent' düğümü bir araç çağrısı planladığında
    # bu düğüme geçiş yapar ve burada o aracı çalıştırırız.
    
    # Basitlik adına, agent_executor.invoke içindeki verbose çıktısından tool çağrısını yakalamak yerine
    # LangChain'in araç çağırma mantığını kullanacağız.
    # Daha sağlam bir yaklaşım için, agent.run(state["user_query"]) ile ayrı bir ajan çalıştırmak
    # ve onun tool call'larını ayrıştırmak gerekir.
    
    # Bu örnek için, 'run_agent' zaten araç çağrısını handle edip output'u döneceği için
    # bu düğümü sadece bir placeholder olarak tutalım veya daha gelişmiş bir akış için kullanalım.
    
    # Eğer agent_executor direkt output döndürmüyorsa, burada manuel olarak aracı çalıştırmalıyız.
    # Örneğin:
    # tool_name = "get_menu"
    # tool_args = {"item_name": "latte"}
    # tool_result = globals()[tool_name](**tool_args)
    # return {"tools_output": tool_result, "chat_history": state["chat_history"] + [f"AI (tool result): {tool_result}"]}
    
    # Mevcut LangChain AgentExecutor yapısı, tool'u çağırıp sonucunu 'output' olarak döndürür.
    # Dolayısıyla bu 'call_tool' düğümüne doğrudan bir geçiş yapmak yerine, 'run_agent'ın
    # LLM çıktısına göre farklı yollara dallanabiliriz.
    
    # Bu senaryoda 'run_agent' her şeyi kapsadığı için, 'call_tool' düğümünü sadece
    # eğer LLM'den özel bir tool çağrısı yapmasını bekliyorsak kullanırız.
    
    # LangGraph'ın temel yapısı genellikle şöyledir:
    # LLM_Node -> (Conditional Edge: Has Tool Call? -> Tool_Node | No Tool Call? -> Human_Response_Node)
    
    # Bu örnekte daha basitleştirilmiş bir akış için, 'run_agent'ı tek bir ana işlem düğümü olarak kullanalım.
    # Veya, 'run_agent'tan dönen 'tool_calls' listesini analiz edip buradan devam edelim.
    
    # Varsayımsal olarak, 'run_agent' eğer bir araç çağırdıysa, durumu buna göre güncellediğini varsayalım.
    # Yani, AgentExecutor içindeki tool çağrıları burada işleniyormuş gibi düşüneceğiz.
    
    # Bu karmaşıklığı azaltmak adına, LangGraph'ta agent_executor'ı direkt çağırıp onun çıktısına göre
    # hareket edeceğiz.
    
    # Eğer state'te bir 'tool_call' bilgisi varsa, onu işletelim
    # (Bu kısım, daha gelişmiş LangGraph örneklerinde 'tool_executor' ile yönetilir)
    
    # Şimdilik, sadece bir geçiş noktası olarak dursun, run_agent tüm işi yapsın.
    # Gelişmiş durumda:
    # tool_calls = state.get("tool_calls", [])
    # for tool_call in tool_calls:
    #    tool_name = tool_call["name"]
    #    tool_args = tool_call["args"]
    #    result = globals()[tool_name](**tool_args)
    # return {"tools_output": result, ...}
    
    return state # Şimdilik state'i olduğu gibi dönsün

def decide_next_step(state: AgentState) -> str:
    """Ajanın mevcut duruma göre bir sonraki adımı belirlediği karar düğümü."""
    print("---KARAR DÜĞÜMÜ ÇALIŞIYOR---")
    # Eğer kullanıcıya cevap verildi ve sipariş tamamlanmadıysa, tekrar ajan çalıştırmaya devam et.
    # Eğer son mesajda "siparişiniz hazırlanıyor" gibi bir ifade varsa, END'e geç.

    last_ai_message = state["chat_history"][-1] if state["chat_history"] else ""

    if "siparişiniz hazırlanıyor" in last_ai_message.lower() or "ödeme başarıyla alındı" in last_ai_message.lower():
        return "end_conversation"
    elif "menüde bulunmamaktadır" in last_ai_message.lower():
        # Ürün bulunamadı, ajanın tekrar denemesini veya yeni bir soru sormasını isteyelim
        return "agent"
    elif not state.get("current_order"): # Henüz sipariş alınmadıysa
        return "agent"
    elif state.get("current_order") and not state.get("order_total"): # Sipariş var ama tutar hesaplanmadıysa
        return "agent"
    elif state.get("order_total") and state.get("payment_status") != "başarılı": # Tutar var ama ödeme yapılmadıysa
        return "agent"
    
    return "agent" # Varsayılan olarak ajana geri dön
    
# Grafımızı inşa edelim
workflow = StateGraph(AgentState)

# Düğümleri ekleyelim
workflow.add_node("agent", run_agent) # Ajanın düşünme ve karar verme/tool çağırma düğümü
workflow.add_node("tool_node", call_tool) # Araçların çağrıldığı düğüm (şimdilik pasif)

# Giriş noktasını belirleyelim
workflow.set_entry_point("agent")

# Geçişleri tanımlayalım
# Ajan çalıştığında bir karar düğümüne gitsin
workflow.add_edge("agent", "decide_next_step") # Bunu böyle yapamayız, geçişler direkt düğümlere olmalı.

# Yeni bir karar düğümü ekleyelim ve geçişleri ona bağlayalım
# Karar düğümü doğrudan LangGraph'ın 'conditional_edge' mekanizmasıdır.
workflow.add_conditional_edges(
    "agent", # 'agent' düğümünden sonra
    decide_next_step, # Karar fonksiyonu
    {
        "agent": "agent", # Eğer "agent" dönerse, tekrar ajana git (bir sonraki kullanıcı girdisini bekle)
        "end_conversation": END # Eğer "end_conversation" dönerse, sohbeti bitir
    }
)
# Başlangıçta agent'tan sonraki geçişi manuel olarak ayarlamamız gerekiyor.
# Bizim 'decide_next_step' fonksiyonumuz aslında bir sonraki adımın adını dönüyor.
# Ancak LangGraph'ta conditional_edges bir fonksiyona dayanır.

# Düzeltilmiş LangGraph akışı
# Düğümleri tanımlayalım
def agent_node(state: AgentState):
    """Ajanın LLM'i kullanarak bir sonraki eylemi belirlediği ve araçları çağırdığı düğüm."""
    print("\n---AGENT NODE BAŞLADI---")
    user_query = state["user_query"]
    
    # LangChain AgentExecutor'ı doğrudan çağırıyoruz. Bu, LLM'in düşünmesini ve gerekirse araçları çağırmasını sağlar.
    # handle_parsing_errors=True ekleyelim
    response = agent_executor.invoke({
        "input": user_query,
        "chat_history": state["chat_history"]
    }, handle_parsing_errors=True)
    
    ai_message = response.get("output", "Üzgünüm, anlayamadım.")
    
    # State'i güncelle
    new_state = {
        "chat_history": state["chat_history"] + [f"AI: {ai_message}"],
        "user_query": "" # Kullanıcı girdisini sıfırla
    }
    
    # Sipariş ve ödeme durumu güncellemeleri
    if "siparişiniz hazırlanıyor" in ai_message.lower():
        new_state["payment_status"] = "başarılı"
    
    # Mevcut sipariş güncellemeleri, daha gelişmiş bir parsing ile yapılabilir
    # Örnek: "1 latte, 2 muffin" => {"latte": 1, "muffin": 2}
    # Bu ajanın çıktısını parse etmeyi gerektirir. Basitlik adına şu an için LLM'in
    # kendi kendine bu state'i manipüle etmediğini varsayalım.
    # Gelişmiş senaryolarda, agent_executor'ın tool_calls'larını yakalayıp
    # buradan state'i güncelleyebiliriz.
    
    print(f"Agent Node Çıktısı: {ai_message}")
    return new_state

def final_check(state: AgentState) -> str:
    """Siparişin durumuna göre bir sonraki adımı belirleyen karar düğümü."""
    print("\n---FİNAL KONTROL DÜĞÜMÜ---")
    last_ai_message = state["chat_history"][-1]
    
    if "siparişiniz hazırlanıyor" in last_ai_message.lower() or "ödeme başarıyla alındı" in last_ai_message.lower():
        return "end_conversation"
    # Eğer kullanıcı "menüyü göster" gibi bir şey dediyse ve menü gösterildiyse, yine de ajana geri dön
    # aksi takdirde kullanıcı başka bir şey isteyebilir.
    return "continue_chat"

workflow = StateGraph(AgentState)
workflow.add_node("agent_node", agent_node)

workflow.set_entry_point("agent_node")

workflow.add_conditional_edges(
    "agent_node", # agent_node'dan sonra
    final_check,  # Karar fonksiyonumuz
    {
        "end_conversation": END, # Eğer end_conversation dönerse, akışı bitir
        "continue_chat": "agent_node" # Aksi halde, tekrar agent_node'a dön (yeni kullanıcı girdisi için)
    }
)

# Grafı derleyelim
app = workflow.compile()
    

Uzman İpucu: LangGraph'ta her bir düğümün (node) sadece state'i alıp yeni bir state döndürdüğünden emin olun. Bu, grafın akışını tutarlı ve izlenebilir kılar. Karmaşık mantığı düğüm fonksiyonları içinde saklayın.

5. Ajanı Çalıştırma ve Test Etme

Ajanımızı artık test edebiliriz. Müşteri gibi davranarak ajana sipariş verelim.

# Sohbet geçmişini saklamak için basit bir liste
chat_history = []
current_order = {}
order_total = 0.0
payment_status = ""

# Ajanla etkileşim
def chat_with_starbucks_agent(query: str):
    global chat_history, current_order, order_total, payment_status
    
    # LangGraph state'ini oluştur
    inputs = {
        "user_query": query,
        "chat_history": chat_history,
        "current_order": current_order,
        "order_total": order_total,
        "payment_status": payment_status
    }
    
    # Ajanı çalıştır
    result = app.invoke(inputs)
    
    # State'i güncelle
    chat_history = result["chat_history"]
    current_order = result.get("current_order", current_order)
    order_total = result.get("order_total", order_total)
    payment_status = result.get("payment_status", payment_status)
    
    # En son AI yanıtını ekrana yazdır
    last_ai_message = chat_history[-1].replace("AI: ", "")
    print(f"\nStarbucks Ajanı: {last_ai_message}")

# Örnek etkileşimler
chat_with_starbucks_agent("Merhaba, menünüzde neler var?")
chat_with_starbucks_agent("Bir latte alabilir miyim?")
chat_with_starbucks_agent("Büyük boy olsun ve badem sütlü.") # Ajanın bu bilgiyi nasıl işleyeceği, LLM'in tool çağrı yeteneğine bağlı
chat_with_starbucks_agent("Yanına bir de muffin ekler misiniz?")
# calculate_order_total aracını tetiklemesi için net bir ifade gerekebilir
chat_with_starbucks_agent("Toplam ne kadar tuttu?")
chat_with_starbucks_agent("Ödeme yapabilir miyim?") # process_payment aracını tetiklemeli

# LangChain AgentExecutor'ın invoke metodu, tool çıktısını output içinde döner.
# Bu yüzden LangGraph'taki agent_node daha basit kalır.
# Gelişmiş senaryolarda, agent_node içinde agent.stream kullanarak tool_calls'ı yakalayıp ayrı bir düğümde işleyebiliriz.
# Bu örnekte, AgentExecutor'ın doğrudan araçları kullanıp son yanıtı döndürmesiyle yetiniyoruz.
    

Bu kod bloğu, Starbucks Ajanımızın temel iskeletini oluşturur. Gelişmiş hata yönetimi, bağlam takibi ve daha karmaşık sipariş modifikasyonları için AgentState yapımızı ve agent_node fonksiyonumuzu daha detaylı hale getirmemiz gerekebilir. Ancak bu temel yapı, LangChain ve LangGraph'ın nasıl bir arada çalışarak otonom bir ajan oluşturabildiğini göstermektedir. Ajan, müşteri girdisine göre dinamik olarak araçları kullanacak ve sohbeti yönlendirecektir.

İleri Düzey Optimizasyonlar ve En İyi Uygulamalar

Temel bir otonom ajan geliştirdik, ancak gerçek dünya senaryolarında daha sağlam, verimli ve kullanıcı dostu bir sistem için bazı ileri düzey tekniklere ve en iyi uygulamalara ihtiyaç duyarız. Bu bölüm, Starbucks Ajanımızı bir sonraki seviyeye taşıyacak ipuçları sunuyor.

1. Gelişmiş Bağlam Yönetimi ve Bellek

Mevcut durumda, ajanın chat_history üzerinden basit bir bağlam takibi var. Ancak daha zengin bir etkileşim için kalıcı bellek (persistent memory) ve karmaşık bağlam yönetimi kritik öneme sahiptir.

• VectorStore backed Memory: Uzun sohbet geçmişlerini özetlemek ve sadece alakalı bilgiyi LLM'e göndermek için bir vektör veritabanı (Pinecone, ChromaDB gibi) kullanabilirsiniz. Bu, LLM'e gönderilen token sayısını azaltır ve maliyeti düşürürken performansı artırır.
• Structured Memory: Sipariş detayları, müşteri tercihleri gibi yapılandırılmış bilgileri ayrı bir bellekte (Python sözlüğü veya veritabanı) tutmak, LLM'in bu bilgilere daha kolay erişmesini ve manipüle etmesini sağlar. LangChain'in ConversationBufferWindowMemory gibi araçları, kısa süreli bellek için kullanılabilir.
• Retrieval Augmented Generation (RAG): Menü veya sıkça sorulan sorular gibi bilgileri doğrudan LLM'e beslemek yerine, bir RAG sistemi kurarak ajanın sadece ihtiyaç duyduğu anda bu bilgilere erişmesini sağlayın. Bu, menü güncellemelerini kolaylaştırır ve "halüsinasyon" riskini azaltır.

2. Hata Yönetimi ve Sağlamlık

Otonom ajanlar hata yapabilir; araçlar başarısız olabilir veya LLM yanlış bir karar verebilir. Sağlam bir ajan için hata yönetimi çok önemlidir.

• Retry Mekanizmaları: Bir araç çağrısı başarısız olduğunda, ajanın otomatik olarak tekrar denemesini sağlayın. LangGraph, döngüler ve koşullu geçişlerle bu tür mekanizmaları kolayca uygulamanıza olanak tanır.
• Geri Dönüş Stratejileri: Belirli bir görevde birden fazla başarısızlık olduğunda, ajanın insan müdahalesi istemesi veya varsayılan, güvenli bir yanıt vermesi gibi geri dönüş stratejileri tanımlayın.
• Doğrulama ve Onay: Özellikle sipariş alma ve ödeme gibi kritik adımlarda, ajanın müşteriden net onaylar almasını sağlayın. Örneğin, siparişin özetini sunup "Onaylıyor musunuz?" diye sormak.
• Token Limit Yönetimi: Uzun sohbetlerde veya karmaşık görevlerde LLM'in token limitlerine takılmamak için geçmişi özetleme veya en alakalı kısmı seçme stratejileri uygulayın.

3. Performans ve Maliyet Optimizasyonu

LLM çağrıları maliyetli olabilir. Performansı artırırken maliyeti düşürmek için şu yöntemleri kullanabilirsiniz:

• Akıllı LLM Seçimi: Her görev için en güçlü LLM'i kullanmak yerine, basit görevler için daha ucuz ve hızlı modelleri (örn. GPT-3.5 Turbo) tercih edin. Kritik ve karmaşık görevler için GPT-4o gibi daha yetenekli modelleri ayırın.
• Önbellekleme (Caching): Sıkça yapılan menü sorguları gibi aynı çıktıyı veren LLM çağrılarını önbelleğe alın. LangChain'in kendi önbellekleme mekanizmaları mevcuttur.
• Paralel İşleme: Mümkün olduğunca, bağımsız görevleri paralel olarak çalıştırmayı düşünün (ancak bu LangGraph akışını karmaşıklaştırabilir).
• Prompt Mühendisliği: LLM'den istenen çıktıyı en az token ile ve en doğru şekilde alabilmek için prompt'larınızı optimize edin. Açık, öz ve hedefe yönelik prompt'lar kullanın.

4. Güvenlik ve Gizlilik

Müşteri verileriyle çalışırken güvenlik ve gizlilik en üst düzeyde olmalıdır.

• Veri Şifreleme: Müşteri bilgilerini ve ödeme verilerini her zaman şifreli bir şekilde saklayın ve iletin.
• Erişim Kontrolü: Ajanın ve entegre olduğu sistemlerin sadece gerekli verilere eriştiğinden emin olun (Least Privilege Prensibi).
• Giriş Filtreleme: Kötü niyetli veya zararlı girdileri tespit etmek ve engellemek için LLM girişlerini filtreleyin.
• Anonimleştirme: Mümkün olduğunda hassas müşteri verilerini anonimleştirerek kullanın.

5. Kullanıcı Arayüzü (UI) ve Mobil Uyumluluk

Ajanınızın etkileşime girdiği bir kullanıcı arayüzü olacaksa (web veya mobil), bunun da optimize edilmesi gerekir.

/* Mobil cihazlar için temel stil ayarları */
body {
    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
    margin: 0;
    padding: 10px;
    background-color: #f4f7f6;
    color: #333;
}

.chat-container {
    max-width: 600px;
    margin: 20px auto;
    background-color: #fff;
    border-radius: 8px;
    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
    display: flex;
    flex-direction: column;
    min-height: 500px;
}

.messages {
    flex-grow: 1;
    padding: 15px;
    overflow-y: auto;
    border-bottom: 1px solid #eee;
}

.message {
    padding: 8px 12px;
    margin-bottom: 10px;
    border-radius: 15px;
    max-width: 80%;
    word-wrap: break-word;
}

.user-message {
    background-color: #007bff;
    color: white;
    align-self: flex-end;
    margin-left: auto;
}

.ai-message {
    background-color: #e2e6ea;
    color: #333;
    align-self: flex-start;
}

.input-area {
    display: flex;
    padding: 15px;
    border-top: 1px solid #eee;
}

.input-area input[type="text"] {
    flex-grow: 1;
    padding: 10px 15px;
    border: 1px solid #ccc;
    border-radius: 20px;
    margin-right: 10px;
    font-size: 16px;
}

.input-area button {
    background-color: #28a745;
    color: white;
    border: none;
    padding: 10px 20px;
    border-radius: 20px;
    cursor: pointer;
    font-size: 16px;
    transition: background-color 0.3s ease;
}

.input-area button:hover {
    background-color: #218838;
}

/* Mobil uyumluluk için Media Query */
@media (max-width: 768px) {
    .chat-container {
        margin: 0;
        border-radius: 0;
        box-shadow: none;
        height: 100vh; /* Tam ekran yüksekliği */
    }
    .message {
        max-width: 90%;
    }
    .input-area {
        padding: 10px;
    }
    .input-area input[type="text"],
    .input-area button {
        font-size: 14px;
        padding: 8px 12px;
    }
}
    

Yukarıdaki CSS örneği, bir sohbet arayüzünün mobil cihazlarda nasıl daha iyi görüneceğine dair bir fikir vermektedir. max-width: 768px media query'si, ekran genişliği bu değerin altına düştüğünde belirli stillerin (örn. tam ekran yüksekliği, daha küçük yazı tipleri) uygulanmasını sağlar. Bu, ajanın etkileşimde olduğu web veya mobil uygulamalarının farklı cihazlarda sorunsuz bir deneyim sunması için önemlidir.

Bu ileri düzey konuları göz önünde bulundurarak ajanınızı geliştirmeniz, sadece işlevsel değil, aynı zamanda güvenilir, verimli ve kullanıcı dostu bir AI çözümü oluşturmanızı sağlayacaktır.

Sonuç: Geleceğin Kahve Deneyimi ve Sıkça Sorulan Sorular

Bu makalede, LangChain ve LangGraph'ın bir araya gelerek nasıl otonom AI ajanları oluşturabileceğimize dair kapsamlı bir rehber sunduk. Starbucks Ajanı örneği üzerinden, bir LLM'in araçlarla entegrasyonu, durum yönetimi ve karmaşık iş akışlarının nasıl tasarlanabileceğini adım adım gösterdik. Artık sadece komutları takip eden chatbotların ötesine geçerek, kendi başına karar alabilen, dış dünyayla etkileşime girebilen ve hatta hatalarından öğrenebilen akıllı sistemler geliştirebiliriz. Bu tür ajanlar, müşteri deneyimini kişiselleştirme, operasyonel verimliliği artırma ve iş süreçlerini otomatize etme konusunda muazzam bir potansiyele sahiptir.

Otonom ajanların geleceği, sadece kahve siparişleriyle sınırlı değil. Sağlık hizmetlerinden finans sektörüne, eğitimden lojistiğe kadar her alanda, bu teknolojinin insanları tekrarlayan görevlerden kurtararak daha yaratıcı ve stratejik işlere odaklanmasını sağlayacağına inanıyoruz. Ancak, bu yolculukta performans optimizasyonu, hata yönetimi, güvenlik ve gizlilik gibi konulara dikkat etmek, ajanlarımızın başarılı ve sürdürülebilir olmasının anahtarıdır. LangChain ve LangGraph, bu zorlukların üstesinden gelmek için güçlü ve esnek bir çerçeve sunarak geliştiricilere ilham verici bir platform sağlıyor.

Sıkça Sorulan Sorular (SSS)

• S: LangChain ve LangGraph arasındaki temel fark nedir?

  C: LangChain, LLM'lerle uygulama geliştirmek için bir çerçevedir; araçlar, zincirler ve ajanlar gibi bileşenler sunar. LangGraph ise LangChain'in üzerine inşa edilmiştir ve ajanların durum makineleri veya grafikler aracılığıyla daha karmaşık, çok adımlı ve döngüsel iş akışlarını yönetmesini sağlar. Özetle, LangChain LLM'e araç verir, LangGraph bu araçların ne zaman ve nasıl kullanılacağını yöneten orkestrasyonu sağlar.

• S: Otonom bir AI ajanı geliştirmek için hangi programlama dillerini bilmeliyim?

  C: LangChain ve LangGraph ağırlıklı olarak Python tabanlı kütüphaneler olduğu için Python programlama dilinde yetkin olmanız önemlidir. Ek olarak, web tabanlı arayüzler için JavaScript/TypeScript ve CSS bilgisi, veri depolama için SQL bilgisi faydalı olabilir.

• S: Starbucks Ajanı gibi bir projeyi gerçek hayata geçirmek ne kadar zor olur?

  C: Bu makaledeki örnek, kavramsal bir başlangıçtır. Gerçek bir Starbucks Ajanı, menü yönetimi, stok takibi, gerçek zamanlı ödeme entegrasyonları (Stripe, BKM Express vb.), sipariş yönetim sistemleriyle (POS) entegrasyon, hata düzeltme, müşteri doğrulama ve veri güvenliği gibi çok daha karmaşık sistem entegrasyonları gerektirir. Bu nedenle, ciddi bir mühendislik çabası ve sistem mimarisi tasarımı gereklidir.

• S: LLM'ler her zaman doğru cevap verir mi? "Halüsinasyon" nedir?

  C: Hayır, LLM'ler her zaman doğru cevap vermez. "Halüsinasyon", bir LLM'in mevcut verilerle desteklenmeyen, ancak inandırıcı görünen yanlış veya uydurma bilgiler üretmesidir. Ajan geliştirirken, halüsinasyonları en aza indirmek için güvenilir araçlar kullanmak (örn. API'lar), doğru prompt mühendisliği yapmak ve Retrieval Augmented Generation (RAG) gibi tekniklerden faydalanmak önemlidir.

• S: Otonom ajanlar işimi elimden alacak mı?

  C: Otonom ajanların temel amacı insanları tamamen yerinden etmek değil, tekrarlayan, sıkıcı veya yüksek hacimli görevleri üstlenerek insan kaynaklarının daha yaratıcı, stratejik ve empati gerektiren işlere odaklanmasını sağlamaktır. Bu, yeni roller ve iş tanımları yaratacak, mevcut işleri daha verimli ve tatmin edici hale getirecektir. İnsan ve AI'nın işbirliği, geleceğin çalışma modelini şekillendirecektir.