LangChain ile Fonksiyon Çağırma: Sohbet Botlarını Kurumsal Yardımcılara Dönüştürme

LangChain’in fonksiyon çağırma yeteneğiyle sohbet botlarınızı veri tabanları, API’ler ve harici araçlarla entegre ederek kurumsal süreçlerinizi otomatikleştiren akıllı yardımcılar haline getirin. Bu makalede adım adım öğrenin.

Günümüz iş dünyasında yapay zeka, özellikle büyük dil modelleri (LLM’ler), potansiyellerini tam anlamıyla ortaya koymak için sadece “konuşmaktan” fazlasına ihtiyaç duyuyor. Geleneksel sohbet botları, genellikle önceden tanımlanmış senaryolara veya geniş bir bilgi havuzuna dayanarak kullanıcı sorularını yanıtlar. Ancak bu yetenek, bir işletmenin karmaşık, dinamik ve gerçek zamanlı ihtiyaçlarını karşılamakta çoğu zaman yetersiz kalır. Örneğin, bir müşteri temsilcisi “Bu ürünün stok durumu nedir?” diye sorduğunda, botun sadece bir metin yanıtı üretmesi değil, aynı zamanda envanter veri tabanına erişip güncel bilgiyi çekmesi gerekir. İşte tam bu noktada, LLM’lerin sadece bilgi üretmekle kalmayıp, aynı zamanda harici sistemlerle etkileşime girmesini sağlayan “fonksiyon çağırma” (function calling) mekanizması devreye giriyor.

Fonksiyon çağırma, bir yapay zeka modelinin belirli bir görevi yerine getirmek üzere tasarlanmış harici bir aracı veya kodu (bir fonksiyonu) tetikleyebilmesi anlamına gelir. Bu sayede, sohbet botları sadece metin tabanlı etkileşimlerden sıyrılarak gerçek dünya aksiyonlarını gerçekleştirebilen, veri tabanlarını sorgulayabilen, API’leri çağırabilen ve hatta e-posta gönderebilen “kurumsal yardımcılar” (enterprise copilots) haline gelir. Bu dönüşüm, işletmeler için otomasyon, verimlilik ve karar verme süreçlerinde devrim niteliğinde fırsatlar sunar. LangChain gibi güçlü bir çerçeve, bu yeteneği geliştiricilere kolayca sunarak, karmaşık entegrasyonları basitleştirir ve geliştirme sürecini hızlandırır. Bu makale boyunca, LangChain’in fonksiyon çağırma mekanizmasını temelden ileri seviyeye kadar keşfedecek, gerçek dünya senaryolarıyla somutlaştıracak ve kendi kurumsal yardımcılarınızı nasıl inşa edeceğinizi adım adım öğreneceksiniz. Artık yapay zeka, sadece “konuşmak” yerine “yapabilir” bir varlık haline geliyor.

Fonksiyon Çağırma Nedir ve Büyük Dil Modelleri (LLM) İçin Neden Hayati?

Fonksiyon çağırma, en basit ifadeyle, bir büyük dil modelinin (LLM) dış dünyadaki araçları veya API’leri kullanabilme yeteneğidir. LLM’ler, muazzam miktarda metin verisi üzerinde eğitildikleri için insan dilini anlama ve üretme konusunda inanılmaz derecede yeteneklidirler. Ancak, varsayılan olarak, eğitildikleri verilerle sınırlıdırlar ve gerçek zamanlı bilgilere erişemezler ya da somut eylemler gerçekleştiremezler. Örneğin, bir LLM size “bugün hava nasıl olacak?” sorusuna genel bir yanıt verebilir, ancak belirli bir şehrin güncel hava durumunu öğrenmek için bir hava durumu API’sini çağıramaz.

İşte bu noktada fonksiyon çağırma hayati bir rol üstlenir. Geliştiriciler, LLM’e belirli görevleri yerine getirecek “araçlar” (tools) veya “fonksiyonlar” tanımlar. Bu araçlar, aslında LLM’in kendisinin doğrudan yürütemediği ancak dilsel olarak açıklanabilen işlevlerdir. LLM, kullanıcıdan gelen bir komutu veya soruyu analiz eder ve bu komutun hangi aracı kullanarak çözülebileceğine karar verir. Örneğin, “İstanbul’da hava nasıl?” sorusunu alan LLM, elindeki araçlar arasında “hava durumu sorgulama” aracı olduğunu ve bu aracın “şehir adı” parametresi aldığını anlar. Ardından, bu aracı çağırarak gerekli parametreleri doldurur ve aracın çıktısını alarak kullanıcıya doğal dilde bir yanıt olarak sunar.

Bu mekanizma, LLM’lerin sadece birer metin üretici olmaktan çıkıp, dinamik, etkileşimli ve gerçek dünyada faydalı “aracı sistemler” haline gelmelerini sağlar. Bir LLM, bu araçlar sayesinde:

• Gerçek zamanlı verilere erişebilir (borsa bilgileri, güncel haberler, veri tabanı kayıtları).
• Harici sistemlerde eylemler gerçekleştirebilir (e-posta gönderme, takvimde randevu oluşturma, sipariş verme).
• Karmaşık hesaplamalar yapabilir (matematiksel problemler, istatistiksel analizler).
• Kurumsal iş akışlarına entegre olabilir (ERP, CRM sistemleriyle etkileşim).

LangChain, bu fonksiyon çağırma sürecini soyutlayarak geliştiriciler için çok daha erişilebilir hale getirir. LangChain’in sağladığı soyutlamalar sayesinde, Python fonksiyonlarını veya API çağrılarını kolayca LLM’in anlayabileceği araçlara dönüştürebilirsiniz. Bu, LLM’in sadece bir beyin değil, aynı zamanda bir orkestra şefi gibi çeşitli harici kaynakları yönetebilen, gerçek bir kurumsal yardımcı olmasının önünü açar. Dolayısıyla, fonksiyon çağırma, LLM tabanlı uygulamaların yeteneklerini katlayarak, onları sınırlı bir sohbet botundan çok daha fazlasına dönüştüren kritik bir köprüdür.

LangChain Fonksiyon Çağırma Mekanizması Nasıl Çalışır?

LangChain, büyük dil modellerinin (LLM) harici araçlarla etkileşime girmesini sağlayan fonksiyon çağırma mekanizmasını son derece esnek ve anlaşılır bir şekilde sunar. Temel olarak, bu mekanizma üç ana bileşen etrafında döner: Araçlar (Tools), Modeller (Models) ve Ajanlar (Agents). Geliştirici olarak sizin göreviniz, LLM’in kullanabileceği araçları tanımlamak ve bu araçları kullanacak bir ajanı yapılandırmaktır.

1. Araçları Tanımlama (Defining Tools):
Bir araç, aslında bir Python fonksiyonu veya bir API çağrısı gibi, belirli bir görevi yerine getiren bir işlevdir. LangChain, bu araçları LLM’in anlayabileceği bir formata dönüştürür. En yaygın yöntemlerden biri, Pydantic modelleri kullanarak aracın beklediği girdileri (parametreleri) net bir şekilde tanımlamaktır. Bu girdi şeması, LLM’in hangi aracı ne zaman ve hangi argümanlarla çağırması gerektiğini anlamasını sağlar. Örneğin, bir hava durumu aracı, “şehir_adı” parametresi beklediğini bildirebilir.

İşte basit bir hava durumu aracı tanımlama örneği:

from langchain.tools import tool
from pydantic import BaseModel, Field

# Aracın beklediği girdi şemasını tanımlıyoruz
class HavaDurumuGirdi(BaseModel):
    sehir_adi: str = Field(description="Hava durumu sorgulanacak şehrin adı")

@tool("hava_durumu_sorgula", args_schema=HavaDurumuGirdi)
def hava_durumu_sorgula_araci(sehir_adi: str) -> str:
    """Belirtilen şehrin anlık hava durumunu döndürür."""
    # Gerçek dünyada burada bir API çağrısı olurdu (örneğin OpenWeatherMap)
    if sehir_adi.lower() == "istanbul":
        return "İstanbul'da hava açık ve 25 derece. Rüzgar hafif."
    elif sehir_adi.lower() == "ankara":
        return "Ankara'da parçalı bulutlu ve 20 derece. Yağmur beklenmiyor."
    else:
        return f"{sehir_adi} için hava durumu bilgisi bulunamadı."

# Bu 'tool' objesi artık bir LangChain aracıdır.

Yukarıdaki örnekte, @tool dekoratörü ve HavaDurumuGirdi Pydantic modeli sayesinde, LLM'e hava_durumu_sorgula adında bir araç olduğunu ve bu aracın sehir_adi adında bir string parametre beklediğini açıkça belirtmiş oluyoruz. LLM, kullanıcıdan gelen "Ankara'da hava nasıl?" gibi bir ifadeyi algıladığında, bu aracı çağırabileceğini ve "Ankara" değerini sehir_adi parametresine atayabileceğini anlar.

2. Modeli ve Ajanı Yapılandırma:
Araçlar tanımlandıktan sonra, bu araçları kullanacak bir LLM'e (model) ve bu LLM'i yönetecek bir ajana (agent) ihtiyacımız var. LangChain, OpenAI'nin fonksiyon çağırma özelliğini doğal olarak destekleyen modelleri (örneğin ChatOpenAI) ve bu modellerle uyumlu ajanları (örneğin OpenAIFunctionsAgent) sağlar.

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

# OpenAI modelimizi yüklüyoruz
llm = ChatOpenAI(model="gpt-4o", temperature=0) # Model ismini ihtiyacınıza göre değiştirebilirsiniz

# Tanımladığımız araçları bir listeye ekliyoruz
tools = [hava_durumu_sorgula_araci]

# Ajan için bir prompt şablonu oluşturuyoruz
prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "Sen kullanıcının sorularını yanıtlayan ve hava durumu bilgisi sağlayabilen yardımcı bir asistansın."),
        MessagesPlaceholder("chat_history"),
        ("human", "{input}"),
        MessagesPlaceholder("agent_scratchpad"),
    ]
)

# OpenAI fonksiyon araçları için ajanı oluşturuyoruz
agent = create_openai_tools_agent(llm, tools, prompt)

# AgentExecutor'ı oluşturuyoruz. Bu, ajanın adım adım düşünmesini ve araçları kullanmasını sağlar.
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# Ajanla etkileşime geçelim
response = agent_executor.invoke({"input": "İstanbul'da hava nasıl?"})
print(response["output"])

response = agent_executor.invoke({"input": "Merhaba, nasılsın?"})
print(response["output"])

response = agent_executor.invoke({"input": "Bana Ankara'nın hava durumunu söyleyebilir misin?"})
print(response["output"])

Yukarıdaki kod bloğunda:

• ChatOpenAI, seçtiğimiz LLM'i temsil eder.
• tools listesi, ajanın kullanabileceği tüm araçları içerir.
• ChatPromptTemplate, LLM'e nasıl davranması gerektiğini ve kullanıcı girdilerini nasıl işlemesi gerektiğini belirten bir şablondur. MessagesPlaceholder("agent_scratchpad") kısmı, ajanın düşünme sürecini (hangi aracı seçeceğini, çıktısını vb.) takip etmesi için önemlidir.
• create_openai_tools_agent, LLM'i ve araçları kullanarak akıllı bir ajan oluşturur. Bu ajan, gelen soruları anlar, uygun aracı seçer, parametreleri doldurur ve aracı çağırır.
• AgentExecutor ise ajanı çalıştıran yapıdır. verbose=True parametresi, ajanın hangi adımları attığını (düşünme süreci, araç çağırma, araç çıktısı) konsola yazdırmasını sağlar, bu da hata ayıklama için çok değerlidir.

Kısacası, LangChain'in fonksiyon çağırma mekanizması, LLM'in bir aracı çağırması gerektiğinde, bu aracın tanımını (adını, açıklamasını, beklediği parametreleri) kullanarak bir "araç çağırma" (tool call) mesajı üretmesine dayanır. Bu mesaj, LangChain tarafından yakalanır ve gerçek Python fonksiyonu veya API çağrısı bu mesajdaki bilgilere göre yürütülür. Elde edilen sonuç daha sonra LLM'e geri beslenir ve LLM bu bilgiyi kullanarak kullanıcıya nihai yanıtını oluşturur. Bu döngü, LLM'in sınırlı bilgi setini aşarak dış dünyayla etkileşime girmesini mümkün kılar.

Gerçek Dünya Senaryosu: Kurumsal Kaynak Planlama (ERP) Asistanı Nasıl Oluşturulur?

Bir işletmenin günlük operasyonlarında en kritik sistemlerden biri Kurumsal Kaynak Planlama (ERP) yazılımlarıdır. Stok yönetimi, sipariş oluşturma, müşteri bilgileri sorgulama, finansal raporlama gibi birçok temel işlevi barındırırlar. Ancak bu sistemler genellikle karmaşık arayüzlere sahiptir ve çalışanların verileri hızlıca çekmesi veya işlemler yapması zaman alabilir. İşte LangChain'in fonksiyon çağırma yeteneği ile bu süreci nasıl basitleştirebileceğimize dair bir örnek: bir ERP asistanı.

Problem: Satış temsilcileri veya depo çalışanları, bir ürünün stok durumunu öğrenmek, yeni bir müşteri siparişi oluşturmak veya belirli bir müşterinin önceki sipariş geçmişini görmek için ERP sistemine giriş yapmak, menülerde gezinmek ve ilgili ekranlara ulaşmak zorunda kalıyor. Bu, zaman kaybına ve operasyonel verimsizliğe yol açıyor.

Çözüm: LangChain tabanlı bir ERP asistanı oluşturarak, çalışanların doğal dil komutlarıyla bu işlemleri doğrudan bir sohbet arayüzü üzerinden gerçekleştirmesini sağlayabiliriz. Asistan, ERP sisteminin API'lerini (veya basit Python fonksiyonlarını) arka planda çağırarak istenen bilgiyi çekecek veya işlemi gerçekleştirecektir.

Adım Adım Uygulama:

1. ERP API Fonksiyonlarını Tanımlama (Simüle Edilmiş):
Gerçek bir senaryoda, bu fonksiyonlar şirketinizin ERP sisteminin REST API'lerine çağrı yapardı. Ancak burada, konuyu basitleştirmek adına Python fonksiyonlarıyla bu API çağrılarını simüle edeceğiz.

from langchain.tools import tool
from pydantic import BaseModel, Field
from typing import List, Dict

# Simüle edilmiş bir veritabanı
PRODUCTS_DB = {
    "Laptop X": {"stok": 15, "fiyat": 1200},
    "Mouse Y": {"stok": 50, "fiyat": 25},
    "Keyboard Z": {"stok": 30, "fiyat": 75}
}
CUSTOMER_DB = {
    "ACME Corp": {"adres": "123 Main St", "siparisler": ["ORDER_001", "ORDER_002"]},
    "Globex Inc": {"adres": "456 Side Ave", "siparisler": ["ORDER_003"]}
}
ORDERS_DB = {
    "ORDER_001": {"musteri": "ACME Corp", "urun": "Laptop X", "adet": 2, "durum": "Tamamlandı"},
    "ORDER_002": {"musteri": "ACME Corp", "urun": "Mouse Y", "adet": 10, "durum": "Bekliyor"},
    "ORDER_003": {"musteri": "Globex Inc", "urun": "Keyboard Z", "adet": 5, "durum": "Tamamlandı"}
}

# Araç 1: Ürün stok durumunu sorgulama
class UrunStokGirdi(BaseModel):
    urun_adi: str = Field(description="Stok durumu sorgulanacak ürünün adı")

@tool("urun_stok_sorgula", args_schema=UrunStokGirdi)
def urun_stok_sorgula_araci(urun_adi: str) -> str:
    """Belirtilen ürünün güncel stok durumunu döndürür."""
    urun_adi_normal = urun_adi.strip()
    if urun_adi_normal in PRODUCTS_DB:
        stok = PRODUCTS_DB[urun_adi_normal]["stok"]
        return f"{urun_adi_normal} ürününden stokta {stok} adet bulunmaktadır."
    return f"{urun_adi_normal} ürünü bulunamadı veya stok bilgisi mevcut değil."

# Araç 2: Yeni bir müşteri siparişi oluşturma
class SiparisOlusturGirdi(BaseModel):
    musteri_adi: str = Field(description="Siparişin verileceği müşterinin adı")
    urun_adi: str = Field(description="Sipariş verilecek ürünün adı")
    adet: int = Field(description="Sipariş verilecek ürünün adedi")

@tool("siparis_olustur", args_schema=SiparisOlusturGirdi)
def siparis_olustur_araci(musteri_adi: str, urun_adi: str, adet: int) -> str:
    """Yeni bir müşteri siparişi oluşturur."""
    if urun_adi not in PRODUCTS_DB:
        return f"Hata: {urun_adi} adlı ürün mevcut değil."
    if musteri_adi not in CUSTOMER_DB:
        return f"Hata: {musteri_adi} adlı müşteri mevcut değil."
    if PRODUCTS_DB[urun_adi]["stok"] < adet:
        return f"Hata: {urun_adi} için yeterli stok yok. Mevcut stok: {PRODUCTS_DB[urun_adi]['stok']}"
    
    # Sipariş oluşturma simülasyonu
    order_id = f"ORDER_{len(ORDERS_DB) + 1:03d}"
    ORDERS_DB[order_id] = {"musteri": musteri_adi, "urun": urun_adi, "adet": adet, "durum": "Yeni"}
    PRODUCTS_DB[urun_adi]["stok"] -= adet # Stoğu güncelle
    return f"Yeni sipariş başarıyla oluşturuldu! Sipariş No: {order_id}. {musteri_adi} için {urun_adi} ürününden {adet} adet sipariş edildi."

# Araç 3: Müşteri sipariş geçmişini sorgulama
class MusteriSiparisGecmisiGirdi(BaseModel):
    musteri_adi: str = Field(description="Sipariş geçmişi sorgulanacak müşterinin adı")

@tool("musteri_siparis_gecmisi_sorgula", args_schema=MusteriSiparisGecmisiGirdi)
def musteri_siparis_gecmisi_sorgula_araci(musteri_adi: str) -> str:
    """Belirtilen müşterinin sipariş geçmişini döndürür."""
    if musteri_adi not in CUSTOMER_DB:
        return f"Hata: {musteri_adi} adlı müşteri bulunamadı."
    
    siparis_idler = CUSTOMER_DB[musteri_adi].get("siparisler", [])
    if not siparis_idler:
        return f"{musteri_adi} için herhangi bir sipariş bulunamadı."
    
    gecmis = []
    for order_id in siparis_idler:
        order_info = ORDERS_DB.get(order_id, {})
        if order_info:
            gecmis.append(f"Sipariş No: {order_id}, Ürün: {order_info.get('urun')}, Adet: {order_info.get('adet')}, Durum: {order_info.get('durum')}")
    return f"{musteri_adi} sipariş geçmişi:\n" + "\n".join(gecmis)

2. Ajanı Oluşturma ve Yapılandırma:
Şimdi, bu araçları kullanacak bir LangChain ajanı oluşturalım. OpenAI'nin fonksiyon çağırma özelliğiyle uyumlu olan create_openai_tools_agent'ı kullanacağız.

from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

# OpenAI modelimizi yüklüyoruz
llm = ChatOpenAI(model="gpt-4o", temperature=0)

# Tanımladığımız tüm araçları bir listeye ekliyoruz
erp_tools = [
    urun_stok_sorgula_araci,
    siparis_olustur_araci,
    musteri_siparis_gecmisi_sorgula_araci
]

# Ajan için bir prompt şablonu oluşturuyoruz
erp_prompt = ChatPromptTemplate.from_messages(
    [
        ("system", "Sen bir ERP asistanısın. Stok, sipariş ve müşteri bilgileri konularında yardımcı olabilirsin. Lütfen her zaman doğru bilgiyi vermeye çalış."),
        MessagesPlaceholder("chat_history"),
        ("human", "{input}"),
        MessagesPlaceholder("agent_scratchpad"),
    ]
)

# ERP ajanını oluşturuyoruz
erp_agent = create_openai_tools_agent(llm, erp_tools, erp_prompt)

# AgentExecutor'ı oluşturuyoruz
erp_agent_executor = AgentExecutor(agent=erp_agent, tools=erp_tools, verbose=True)

# Ajanla etkileşim örnekleri
print("-----------------------------------")
print("ERP Asistanı ile Etkileşimler:")
print("-----------------------------------")

# Örnek 1: Stok sorgulama
response1 = erp_agent_executor.invoke({"input": "Laptop X ürününün stok durumu nedir?"})
print(response1["output"])
print("\n")

# Örnek 2: Yeni sipariş oluşturma
response2 = erp_agent_executor.invoke({"input": "ACME Corp için Keyboard Z ürününden 3 adet sipariş oluştur."})
print(response2["output"])
print("\n")

# Örnek 3: Müşteri sipariş geçmişi
response3 = erp_agent_executor.invoke({"input": "ACME Corp'un önceki siparişlerini göster."})
print(response3["output"])
print("\n")

# Örnek 4: Tanımsız istek
response4 = erp_agent_executor.invoke({"input": "Bana en son borsa haberlerini getir."})
print(response4["output"])
print("\n")

Çalışma Mekanizmasının Görseli (Betimleme):

Bu senaryoyu görselleştirecek olursak:

1. Kullanıcı Sorgusu: Çalışan, ERP asistanına doğal dilde bir soru sorar: "ACME Corp için Keyboard Z ürününden 3 adet sipariş oluştur."
2. LLM Analizi: LangChain ajanı, bu sorguyu alır ve LLM'e iletir. LLM, elindeki araç tanımlarını (siparis_olustur_araci gibi) inceleyerek bu sorgunun bir sipariş oluşturma işlemi olduğunu anlar.
3. Fonksiyon Çağırma Kararı: LLM, siparis_olustur_araci'nı çağırmaya karar verir ve gerekli parametreleri (musteri_adi="ACME Corp", urun_adi="Keyboard Z", adet=3) çıkarır.
4. Araç Yürütme: LangChain, bu kararı alır ve simüle edilmiş Python fonksiyonunu (siparis_olustur_araci) belirtilen parametrelerle çalıştırır. Bu fonksiyon, ERP sisteminin API'sini çağırarak gerçek bir sipariş oluşturur (veya örneğimizde veritabanımızı günceller).
5. Geri Dönüş ve Yanıt: Fonksiyon, "Yeni sipariş başarıyla oluşturuldu! Sipariş No: ORDER_004. ACME Corp için Keyboard Z ürününden 3 adet sipariş edildi." gibi bir çıktı döndürür. Bu çıktı tekrar LLM'e iletilir.
6. Nihai Yanıt: LLM, bu fonksiyon çıktısını kullanarak kullanıcıya doğal dilde, anlaşılır bir yanıt sunar.

Bu örnekte görüldüğü gibi, LangChain'in fonksiyon çağırma özelliği, karmaşık kurumsal iş akışlarını doğal dil etkileşimleriyle otomatikleştirmek için güçlü bir köprü görevi görür. Bu sadece bir başlangıç olup, şirket içi belgeleri sorgulamadan, takvim randevuları ayarlamaya kadar birçok farklı senaryo için genişletilebilir.

İleri Düzey Fonksiyon Çağırma Stratejileri: Zincirler ve Geri Bildirim Mekanizmaları

LangChain ile fonksiyon çağırmanın temel mekanizmasını anladığımıza göre, şimdi daha karmaşık ve gerçek dünya senaryolarında karşılaşabileceğimiz ileri düzey stratejilere odaklanabiliriz. Basit tek seferlik araç çağrılarının ötesine geçerek, çok adımlı görevleri yönetmek, hataları ele almak ve daha sağlam sistemler inşa etmek için bazı gelişmiş tekniklere bakalım.

Karmaşık İş Akışları İçin Araç Zincirleri Nasıl Oluşturulur?

Bazen bir kullanıcının isteği, tek bir aracın çağrılmasıyla tamamlanamaz. Birden fazla aracın sırayla veya koşullu olarak çalıştırılması gerekebilir. LangChain ajanları, bu "düşünme" yeteneğine sahiptir; yani bir aracı çağırdıktan sonra çıkan sonucu değerlendirip başka bir aracı çağırmaya karar verebilirler. Bu, bir "araç zinciri" oluşturulmasına olanak tanır. Örneğin:

"Bir müşterinin tüm siparişlerini getir, sonra o siparişlerdeki ürünlerin stok durumunu kontrol et."

Bu senaryo için ajan, önce musteri_siparis_gecmisi_sorgula_araci'nı çağıracak, ardından her bir siparişteki ürün için urun_stok_sorgula_araci'nı çağırarak nihai yanıtı oluşturacaktır. Ajanın AgentExecutor yapısı, bu ardışık düşünme ve eylem adımlarını otomatik olarak yönetir.

# Yukarıdaki ERP araçlarını ve ajan kurulumunu varsayıyoruz.
# Ajan, bu tür çok adımlı görevleri zaten 'verbose=True' ile gözlemleyebileceğimiz içsel bir düşünme süreciyle yönetir.
# Örnek: "ACME Corp'un en son siparişindeki ürünlerin stok durumunu bana bildir."
# Bu durumda ajan:
# 1. ACME Corp'un sipariş geçmişini sorgular.
# 2. En son siparişi belirler.
# 3. Bu siparişteki her bir ürün için stok sorgular.
# 4. Tüm bilgileri toplayıp kullanıcıya sunar.

response_complex = erp_agent_executor.invoke({"input": "ACME Corp'un en son siparişindeki ürünlerin stok durumunu bana bildir."})
print(response_complex["output"])

Bu örnekte, ajan tek bir araç çağrısı yerine, birden fazla aracı ardışık olarak kullanarak karmaşık bir isteği yerine getirebilir. LLM'in kendisi, araçların çıktısını yorumlama ve bir sonraki adımı planlama zekasına sahiptir.

Hata Yönetimi ve Geri Bildirim Mekanizmaları Nasıl Sağlanır?

Gerçek dünya sistemleri mükemmel değildir. API çağrıları başarısız olabilir, veri tabanları erişilemez olabilir veya bir araç beklenmedik bir hata fırlatabilir. LangChain'de bu durumları ele almak için çeşitli stratejiler mevcuttur:

• Araç İçi Hata Yakalama: Her bir aracın kendi içerisinde try-except blokları kullanarak olası hataları yakalaması ve LLM'e anlaşılır bir hata mesajı döndürmesi en iyi yaklaşımdır. Bu, LLM'in hatayı yorumlayıp kullanıcıya mantıklı bir geri bildirim sunmasını sağlar.
• AgentExecutor Hata Yönetimi: AgentExecutor, çalışma sırasında bir araç çağrısı başarısız olursa veya beklenmeyen bir durumla karşılaşırsa bunu yönetir. Ancak, daha spesifik senaryolar için max_iterations veya early_stopping_method gibi parametrelerle ajanın davranışını kontrol edebilirsiniz.
• Callback Fonksiyonları: LangChain, ajanın her adımını (girdi, araç çağırma, araç çıktısı, nihai yanıt) izlemek için callback (geri çağırma) fonksiyonları sağlar. Bu fonksiyonları kullanarak, loglama, hata izleme, performans ölçümü veya hatta ara adımlarda insan müdahalesi gibi işlemleri gerçekleştirebilirsiniz.

from langchain.callbacks.base import BaseCallbackHandler
from langchain_core.agents import AgentAction, AgentFinish
from langchain_core.messages import BaseMessage

class MyCustomHandler(BaseCallbackHandler):
    def on_agent_action(self, action: AgentAction, **kwargs):
        print(f"--- Ajan Aksiyonu: {action.log} ---")

    def on_tool_end(self, output: str, **kwargs):
        print(f"--- Araç Çıktısı: {output} ---")

    def on_agent_finish(self, finish: AgentFinish, **kwargs):
        print(f"--- Ajan Tamamlandı: {finish.log} ---")

# AgentExecutor'ı callback'ler ile tekrar oluşturuyoruz
erp_agent_executor_with_callbacks = AgentExecutor(
    agent=erp_agent,
    tools=erp_tools,
    verbose=True,
    callbacks=[MyCustomHandler()] # Callback'i buraya ekliyoruz
)

# Şimdi bir hata senaryosunu test edelim (örneğin olmayan bir ürün sorgulayalım)
print("\n-----------------------------------")
print("Callback'li Hata Senaryosu:")
print("-----------------------------------")
response_error = erp_agent_executor_with_callbacks.invoke({"input": "Olmayan_Urun diye bir ürünün stok durumu nedir?"})
print(response_error["output"])

Bu MyCustomHandler örneği, ajanın her adımında konsola özel mesajlar yazdırarak, ajanın ne düşündüğünü ve hangi araçları hangi çıktılarla kullandığını takip etmenizi sağlar. Gerçek bir uygulamada, bu callback'leri veritabanına loglama, uyarı mekanizmalarını tetikleme veya performans metriklerini toplama gibi amaçlarla kullanabilirsiniz.

Bu ileri düzey stratejiler, LangChain ile oluşturduğunuz kurumsal yardımcıların sadece işlevsel değil, aynı zamanda güvenilir, sağlam ve yönetilebilir olmasını sağlar. İşletme ortamlarında başarı için bu tür detaylara dikkat etmek kritik öneme sahiptir.

Mobil Uyumlu Kurumsal Yardımcılar: HTML ve CSS ile Kullanıcı Deneyimi

Bir kurumsal yardımcının başarısı sadece arka plandaki akıllı işlevselliğine değil, aynı zamanda kullanıcıların onunla ne kadar kolay ve sezgisel bir şekilde etkileşim kurabildiğine de bağlıdır. Modern işgücü, mobil cihazları her an, her yerde kullanma eğiliminde olduğundan, geliştirdiğimiz yardımcıların mobil uyumlu bir kullanıcı arayüzüne sahip olması olmazsa olmazdır. LangChain ajanı ne kadar zeki olursa olsun, kötü bir kullanıcı deneyimi (UX) benimsenmeyi engeller. Bu bölümde, bir LangChain tabanlı kurumsal yardımcının kullanıcı arayüzünü (UI) HTML ve CSS kullanarak nasıl mobil uyumlu hale getirebileceğinizi ele alacağız.

Sohbet Arayüzü İçin Temel HTML Yapısı

Bir sohbet botu arayüzü, genellikle bir mesaj geçmişi alanı ve bir girdi alanı içerir. Basit bir HTML yapısı şöyle olabilir:

    

        
Kurumsal Yardımcı
    
    

        
        
Merhaba, stok durumunu sorgulayabilir misin?
        
Elbette, hangi ürünün stok durumunu öğrenmek istersiniz?
    
    

        
        Gönder
    

Bu yapı, bir sohbet kutusu için temel elementleri sağlar: bir başlık, mesajların görüneceği bir alan ve kullanıcının mesaj yazıp göndereceği bir alan. JavaScript kullanarak (bu makalenin kapsamı dışında olsa da), userInput'tan gelen mesajları alıp LangChain ajanına gönderebilir ve dönen yanıtları chatMessages div'ine ekleyebilirsiniz.

CSS ile Duyarlı (Responsive) Tasarım Nasıl Sağlanır?

Mobil uyumluluğun anahtarı, CSS'in "media query" özelliğidir. Media query'ler, ekran genişliği, cihaz tipi veya yönelim gibi belirli koşullara göre farklı stil kuralları uygulamanıza olanak tanır. Bu sayede, tasarımınız farklı cihazlarda otomatik olarak kendini ayarlar.

/* Genel stiller */
body {
    font-family: Arial, sans-serif;
    margin: 0;
    padding: 0;
    background-color: #f4f7f6;
    display: flex;
    justify-content: center;
    align-items: center;
    min-height: 100vh;
}

.chat-container {
    width: 100%;
    max-width: 450px; /* Büyük ekranlarda maksimum genişlik */
    height: 80vh;
    background-color: #fff;
    box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
    display: flex;
    flex-direction: column;
    border-radius: 8px;
    overflow: hidden;
}

.chat-header {
    background-color: #007bff;
    color: white;
    padding: 15px;
    text-align: center;
    font-size: 1.2em;
}

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

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

.user-message {
    background-color: #e0f7fa;
    align-self: flex-end;
    margin-left: auto;
    color: #333;
}

.bot-message {
    background-color: #f1f0f0;
    align-self: flex-start;
    margin-right: auto;
    color: #555;
}

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

.chat-input input {
    flex-grow: 1;
    padding: 10px;
    border: 1px solid #ccc;
    border-radius: 20px;
    margin-right: 10px;
    font-size: 1em;
}

.chat-input button {
    background-color: #007bff;
    color: white;
    border: none;
    padding: 10px 15px;
    border-radius: 20px;
    cursor: pointer;
    font-size: 1em;
    transition: background-color 0.3s ease;
}

.chat-input button:hover {
    background-color: #0056b3;
}

/* Mobil uyumluluk için medya sorgusu */
@media (max-width: 768px) {
    .chat-container {
        width: 100vw; /* Tam ekran genişliği */
        height: 100vh; /* Tam ekran yüksekliği */
        max-width: none; /* Maksimum genişlik kısıtlamasını kaldır */
        border-radius: 0; /* Köşe yuvarlaklığını kaldır */
    }

    body {
        align-items: flex-start; /* Sohbeti ekranın üstüne hizala */
    }

    .chat-input input {
        padding: 12px;
    }

    .chat-input button {
        padding: 12px 18px;
    }
}

/* Daha küçük cihazlar için ek optimizasyonlar */
@media (max-width: 480px) {
    .chat-header h3 {
        font-size: 1em;
    }
    .chat-messages {
        padding: 10px;
    }
    .message {
        max-width: 90%;
        font-size: 0.9em;
    }
    .chat-input {
        padding: 10px;
    }
    .chat-input input, .chat-input button {
        padding: 8px;
        font-size: 0.9em;
    }
}

Yukarıdaki CSS kodu, .chat-container elementine genel stiller uygular. Ardından, @media (max-width: 768px) sorgusu ile ekran genişliği 768 piksel veya daha az olduğunda devreye giren özel kurallar tanımlarız. Bu kurallar:

• Sohbet kutusunun genişliğini ve yüksekliğini cihazın tamamını kaplayacak şekilde ayarlar (100vw ve 100vh).
• max-width kısıtlamasını kaldırır, böylece daha büyük ekranlardaki sabitlemeyi mobil cihazlarda geçersiz kılar.
• border-radius'u sıfırlayarak tam ekran deneyimi sağlar.
• Daha küçük cihazlar (max-width: 480px) için font boyutları ve padding gibi daha ince ayarlar yapar.

Bu yaklaşım, LangChain ile geliştirdiğiniz akıllı kurumsal yardımcıların sadece arka planda güçlü olmakla kalmayıp, aynı zamanda son kullanıcıya modern, erişilebilir ve mobil uyumlu bir deneyim sunmasını sağlar. Kullanıcı dostu bir arayüz, yeni teknolojilerin kurumsal ortamlarda benimsenmesinde kilit rol oynar ve çalışan verimliliğini doğrudan etkiler.

LangChain ile Kurumsal Dönüşüm: Geleceğin İş Modelleri

LangChain'in fonksiyon çağırma yeteneği, büyük dil modellerinin (LLM'ler) iş dünyasındaki rolünü kökten değiştiriyor. Artık yapay zeka sadece içerik üretmek veya soruları yanıtlamakla kalmıyor; gerçek dünya sistemleriyle etkileşim kurarak somut eylemler gerçekleştirebilen, işletmelerin en karmaşık operasyonlarına bile entegre olabilen akıllı yardımcılar haline geliyor. Bu, kurumsal dönüşüm için eşsiz fırsatlar sunuyor ve geleceğin iş modellerini şekillendiriyor.

Bu makalede gördüğümüz gibi, LangChain, bir LLM'in bir ERP sistemiyle etkileşim kurmasından, bir müşteri hizmetleri talebini işlemesine veya bir finansal raporu otomatik olarak oluşturmasına kadar geniş bir yelpazedeki görevleri üstlenebilen "kurumsal yardımcılar" inşa etmenin yolunu açıyor. Bu yardımcılar, manuel iş yükünü azaltır, insan hatalarını minimize eder ve iş süreçlerini hızlandırır. En önemlisi, çalışanların rutin, tekrarlayan görevler yerine daha stratejik ve yaratıcı işlere odaklanmasını sağlayarak genel verimliliği ve çalışan memnuniyetini artırır.

Fonksiyon çağırmanın kurumsal faydaları özetle şunlardır:

• Otomasyon ve Verimlilik: Elle yapılan birçok işin otomatikleştirilmesi sayesinde iş süreçleri hızlanır ve operasyonel maliyetler düşer.
• Gelişmiş Veri Erişimi: LLM'ler, işletmelerin sahip olduğu derinlemesine veri tabanlarına ve harici API'lere erişerek daha doğru ve güncel bilgilerle karar verme süreçlerini destekler.
• Kişiselleştirilmiş Deneyimler: Müşteri hizmetlerinden iç iletişime kadar her alanda, kullanıcılara özel, bağlamsal ve etkileşimli deneyimler sunulur.
• İş Akışı Entegrasyonu: Mevcut yazılım ve sistemlerle sorunsuz entegrasyon sayesinde, mevcut altyapıdan en iyi şekilde faydalanılır.
• Gelişmiş Karar Verme: Anlık veri analizi ve öngörüler sunarak yöneticilerin daha bilinçli ve hızlı kararlar almasına yardımcı olur.

Gelecekte, bu tür kurumsal yardımcıların daha da sofistike hale geldiğini göreceğiz. Kendi başlarına sorunları tespit edip çözüm önerileri sunan, proaktif olarak aksiyon alan ve hatta diğer yardımcılarla işbirliği içinde çalışan otonom ajanlar ortaya çıkacak. LangChain, bu yenilikçi dönemin öncülerinden biri olarak, geliştiricilere bu güçlü araçları sağlama misyonunu üstleniyor. İşletmelerin bu potansiyeli erkenden keşfetmesi ve stratejik olarak kullanması, rekabet avantajı elde etmeleri için hayati önem taşıyor.

Sıkça Sorulan Sorular

1. LangChain'de fonksiyon çağırma için hangi LLM'leri kullanabilirim?

Genellikle OpenAI'nin GPT-4o, GPT-4 Turbo ve GPT-3.5 Turbo gibi modelleri, yerleşik ve optimize edilmiş fonksiyon çağırma özelliklerine sahip oldukları için tercih edilir. Ancak, diğer LLM sağlayıcıları veya açık kaynaklı modeller de (e.g., Llama 3) LangChain'in araç entegrasyonları aracılığıyla fonksiyon çağırma yeteneğine sahip olabilir, ancak kurulumları farklılık gösterebilir.

2. LangChain fonksiyon çağırmanın güvenlik açısından potansiyel riskleri var mı?

Evet, her güçlü teknolojide olduğu gibi fonksiyon çağırmanın da riskleri vardır. LLM'in yanlış bir araç çağırması veya yanlış parametrelerle bir eylem gerçekleştirmesi durumunda istenmeyen sonuçlar doğabilir (örneğin, yanlış veri silme, hatalı sipariş oluşturma). Bu nedenle, araçlara sıkı erişim kontrolleri uygulamak, kritik işlemler için insan onayı (human-in-the-loop) mekanizmaları eklemek ve tüm etkileşimleri loglamak önemlidir. Ayrıca, kullanıcı girdilerinin temizlenmesi (input sanitization) ve yetkilendirme (authorization) mekanizmaları da kritik öneme sahiptir.

3. Fonksiyon çağırma performansını nasıl optimize edebilirim?

Performansı artırmak için araçlarınızı mümkün olduğunca verimli yazın; gereksiz API çağrılarından veya veri tabanı sorgularından kaçının. LLM'in hızlı yanıt vermesi için model seçimi önemlidir (daha küçük modeller genellikle daha hızlıdır). Ayrıca, prompt mühendisliği ile ajana daha net talimatlar vererek gereksiz "düşünme" adımlarını azaltabilirsiniz. LangChain'in caching mekanizmalarını kullanarak tekrarlayan araç çağrılarının sonuçlarını önbelleğe almayı da düşünebilirsiniz.

4. LangChain fonksiyon çağırma ile sadece API'ler mi çağrılabilir?

Hayır, fonksiyon çağırma sadece harici API'lerle sınırlı değildir. Python'da yazılmış herhangi bir fonksiyonu LangChain aracı olarak tanımlayabilirsiniz. Bu, veri tabanı sorguları, dosya sistemi işlemleri, yerel sistem komutları çalıştırma, karmaşık hesaplamalar yapma veya hatta diğer yapay zeka modellerini çağırma gibi çok çeşitli görevleri kapsar. Önemli olan, aracın ne yapacağını ve hangi girdilere ihtiyaç duyduğunu LLM'in anlayabileceği şekilde tanımlamaktır.