Büyük dil modellerinin (BHM) dönüştürücü gücünü keşfetmeye hazır mısınız? LangChain, bu devrim niteliğindeki modelleri kullanarak akıllı, bağlamsal ve etkileşimli uygulamalar geliştirmenizi sağlayan güçlü bir framework’tür. Bu adım adım rehberimizle, LangChain dünyasına dalacak, temel kavramları öğrenecek ve kendi BHM destekli uygulamalarınızı nasıl inşa edeceğinizi keşfedeceksiniz.
Günümüz yapay zeka dünyasında, OpenAI’nin GPT serisi, Google’ın PaLM’i veya açık kaynaklı modeller gibi Büyük Dil Modelleri (BHM’ler), metin üretme, çeviri yapma, özetleme ve hatta kod yazma gibi inanılmaz yetenekler sunuyor. Ancak bu modellerin saf gücünü alıp gerçek dünya uygulamalarına entegre etmek her zaman sanıldığı kadar basit olmuyor. Genellikle, bir BHM’yi bir uygulamanın kalbine yerleştirmek, sadece bir API çağrısı yapmaktan çok daha fazlasını gerektirir.
Karşılaşılan en yaygın zorluklardan biri, BHM’lerin doğası gereği tek seferlik etkileşimler için tasarlanmış olmasıdır. Yani, her yeni istekte BHM, önceki bağlamı “unutur”. Bir sohbet botu veya kullanıcıyla sürekli diyalog kuran bir asistan geliştirmek istediğinizde, bu bellek eksikliği ciddi bir sorun yaratır. Kullanıcının önceki söylediklerini hatırlamayan bir BHM, doğal ve akıcı bir sohbet deneyimi sunamaz. İşte bu noktada “bellek yönetimi” kritik bir hale gelir.
Ayrıca, BHM’ler genellikle mevcut bilgilerle sınırlıdır; yani, eğitim verilerinde bulunmayan en güncel bilgilere veya kurum içi özel verilere doğrudan erişemezler. Bir BHM’nin dış dünyadan bilgi almasını, web araması yapmasını, bir veritabanını sorgulamasını veya bir API’ye bağlanmasını sağlamak, karmaşık entegrasyonlar gerektirir. Bu tür görevler için BHM’ye “araçlar” sağlamak ve modelin ne zaman hangi aracı kullanacağına karar vermesini öğretmek, önemli bir mühendislik çabası gerektirir.
Bir diğer önemli zorluk ise “prompt mühendisliği”dir. BHM’lerden istenen çıktıyı almak için doğru talimatları, yani “prompt’ları” hazırlamak bir sanattır. Etkili prompt’lar yazmak deneyim gerektirir ve genellikle tekrarlayan deneme-yanılma süreçleri içerir. Uygulama geliştikçe, farklı görevler için farklı prompt’lar tasarlamak ve bunları tutarlı bir şekilde yönetmek karmaşıklaşabilir. BHM’lerle etkileşimleri birden fazla adıma bölmek, bir çıktının diğerinin girişi olduğu “zincirler” oluşturmak da manuel olarak yapıldığında zahmetlidir.
Tüm bu zorluklar, geliştiricilerin BHM’lerin potansiyelini tam olarak kullanmalarını engelleyebilir. Her yeni BHM tabanlı uygulama için bu temel sorunları baştan çözmek, zaman ve kaynak israfına yol açar. İşte tam bu noktada, LangChain gibi bir framework devreye girerek bu karmaşıklıkları soyutlar ve geliştiricilerin daha yüksek seviyeli, akıllı uygulamalar oluşturmaya odaklanmasını sağlar. LangChain, BHM’lerin gücünü gerçekten serbest bırakmak için gereken yapı taşlarını ve soyutlamaları sunar.
LangChain Tam Olarak Nedir ve Büyük Dil Modelleriyle Uygulama Geliştirme Sürecini Nasıl Basitleştirir?
LangChain, Büyük Dil Modelleri (BHM’ler) ile çalışan uygulamalar geliştirmeyi kolaylaştırmak için tasarlanmış, dil modellerini temel alan bir framework’tür. Adından da anlaşılacağı gibi, “LangChain”, dil modellerini birbirine “zincirleme” fikri üzerine kurulmuştur. Amacı, geliştiricilere BHM’lerin yeteneklerini harici veri kaynaklarıyla, hesaplama mantığıyla ve diğer BHM’lerle sorunsuz bir şekilde birleştirebilecekleri modüler bileşenler sunmaktır. Peki, LangChain’i bu kadar özel kılan nedir?
En temel düzeyde LangChain, bir BHM’nin sadece bir metin üreticisi olmaktan çıkıp, karmaşık görevleri yerine getirebilen, kararlar alabilen ve dış dünyayla etkileşime geçebilen bir “akıllı aracıya” dönüşmesine olanak tanır. Bu, özellikle BHM’lerin kendi başlarına yapamadığı veya yapmakta zorlandığı durumlar için hayati önem taşır. Örneğin, bir BHM’nin güncel bir hava durumu bilgisini alması, bir e-tabloyu analiz etmesi veya bir e-postayı göndermesi gibi. LangChain, bu tür işlevsellikleri BHM’nin kavrayışına sunarak, uygulamanızın yeteneklerini katlayarak artırır.
LangChain’in temel felsefesi, modülerlik ve birleştirilebilirlik üzerine kuruludur. Bu, farklı BHM’leri, farklı prompt yapılarını, farklı bellek türlerini ve farklı araçları kolayca bir araya getirip değiştirebileceğiniz anlamına gelir. Bir uygulamanın belirli bir bölümünde OpenAI’nin GPT-4 modelini kullanırken, başka bir bölümünde Hugging Face’in açık kaynaklı bir modelini tercih edebilir veya arama işlevi için Google Arama API’sini, veri alma için özel bir veritabanı bağlayıcısını kullanabilirsiniz. Bu esneklik, geliştiricilere büyük bir özgürlük sunar ve uygulamalarını belirli gereksinimlere göre optimize etmelerine olanak tanır.
Framework, aşağıdaki temel amaçları gerçekleştirmek üzere tasarlanmıştır:
- BHM Entegrasyonu: Çeşitli BHM sağlayıcılarıyla (OpenAI, Hugging Face, Cohere vb.) tutarlı bir arayüz sağlar.
- Veri Farkındalığı: BHM’lerin kendi eğitim verilerinin ötesindeki verilere (belgeler, web sayfaları, veritabanları vb.) erişmesini ve bunları kullanmasını kolaylaştırır.
- Aracılık (Agentic Capabilities): BHM’lerin hangi eylemi yapacaklarına, hangi araçları kullanacaklarına ve adımlarını nasıl sıralayacaklarına karar vermelerini sağlayarak karmaşık görevleri otomatikleştirir.
- Zincirleme (Chaining): Birden fazla BHM çağrısını veya diğer bileşenleri mantıksal bir sıra halinde birleştirerek karmaşık iş akışları oluşturmayı sağlar.
- Bellek Yönetimi: Sohbet geçmişi gibi durumu yöneterek BHM’lerin önceki etkileşimleri hatırlamasını ve bağlamı korumasını sağlar.
Özetle, LangChain, BHM’lerin potansiyelini sonuna kadar kullanmak isteyen geliştiriciler için vazgeçilmez bir köprü görevi görür. BHM’leri sadece metin üreticileri olmaktan çıkarıp, akıllı, bağlamsal ve dış dünyayla etkileşime geçebilen güçlü uygulamaların temel yapı taşları haline getirir. Bu sayede, daha karmaşık ve değerli yapay zeka uygulamalarını çok daha hızlı ve verimli bir şekilde geliştirebiliriz.
LangChain’in Temel Bileşenleri Nelerdir ve Nasıl Çalışırlar?
LangChain’in gücü, modüler ve birleştirilebilir bileşenlerinden gelir. Bu bileşenleri anlamak, LangChain ile nasıl daha akıllı uygulamalar geliştirebileceğinizin anahtarıdır. İşte LangChain’in en önemli yapı taşları:
Modeller (Models): Yapay Zeka Beyniyle Etkileşim
LangChain’in temelinde, farklı Büyük Dil Modelleri (BHM’ler) ile etkileşim kurma yeteneği yatar. LangChain bu modelleri üç ana kategoriye ayırır:
- LLM’ler (Large Language Models): Metin girdisi alıp metin çıktısı üreten genel amaçlı dil modelleridir. Genellikle tek bir dize olarak girdi alırlar ve tek bir dize olarak çıktı verirler. Örneğin, bir metni özetlemek veya bir soruya kısa bir cevap vermek için kullanılabilirler.
- Chat Modelleri (Chat Models): Sohbet tabanlı etkileşimler için özel olarak tasarlanmıştır. Girdi olarak bir mesaj listesi (kullanıcı, sistem, yapay zeka mesajları) alırlar ve bir mesaj çıktısı (genellikle yapay zeka mesajı) verirler. Bu, sohbet robotları ve diyalog sistemleri için idealdir, çünkü modelin konuşmanın akışını ve rollerini (kullanıcı vs. asistan) daha iyi anlamasını sağlar.
- Embedding Modelleri (Embedding Models): Metinleri sayısal vektör gösterimlerine (embedding’lere) dönüştüren modellerdir. Bu vektörler, metinler arasındaki semantik benzerliği ölçmek için kullanılabilir. Örneğin, bir sorguya en alakalı belgeleri bulmak veya benzer cümleleri gruplamak için embedding’ler vazgeçilmezdir.
LangChain, bu farklı model türleri için standart bir arayüz sağlayarak, altyapıyı değiştirmeden farklı sağlayıcıların (OpenAI, Hugging Face, Cohere vb.) modelleri arasında geçiş yapmayı kolaylaştırır. Bu, projenizin ihtiyaçlarına en uygun modeli seçme esnekliği sunar.
Promptler (Prompts): Modellere Doğru Talimatları Verme Sanatı
Bir BHM’den istediğiniz çıktıyı almanın yolu, ona doğru “prompt’u” vermekten geçer. LangChain, prompt’ları oluşturmayı ve yönetmeyi kolaylaştırmak için güçlü araçlar sunar:
- PromptTemplate: Sabit metinler ve dinamik olarak doldurulacak değişkenler içeren şablonlar oluşturmanızı sağlar. Bu sayede, aynı yapıyı koruyarak farklı girdilerle prompt’lar üretebilirsiniz. Örneğin, bir şirket adı veya bir konu başlığına göre özelleştirilmiş bir prompt oluşturmak mümkündür.
- OutputParsers: BHM’den gelen ham metin çıktısını yapılandırılmış verilere (JSON, Python objeleri vb.) dönüştürmek için kullanılır. Bu, BHM çıktısının daha sonraki işlemler veya uygulamalarınızın geri kalanı tarafından kolayca kullanılmasını sağlar.
Prompt mühendisliği, BHM uygulamalarının başarısı için kritik öneme sahiptir ve LangChain, bu süreci daha yönetilebilir hale getirerek geliştiricilerin en iyi sonuçları elde etmelerine yardımcı olur.
Zincirler (Chains): Adım Adım İş Akışları Oluşturma
LangChain’in adını veren temel bileşenlerden biri “Chain”lerdir. Chain’ler, birden fazla bileşeni (BHM çağrıları, diğer chain’ler, araçlar, veri işlemciler vb.) bir araya getirerek karmaşık ve çok adımlı iş akışları oluşturmanıza olanak tanır. Bir çıktının, bir sonraki adımın girdisi olduğu ardışık işlemleri tanımlamak için kullanılırlar.
- LLMChain: Belirli bir PromptTemplate ve bir LLM’yi bir araya getiren en basit zincir türüdür. Model çağrısını ve prompt biçimlendirmeyi tek bir adımda kapsar.
- SequentialChain: Birden fazla zinciri sıralı olarak birbirine bağlar. Bir önceki zincirin çıktısı, bir sonrakinin girdisi olur. Bu, karmaşık görevleri daha küçük, yönetilebilir adımlara bölmek için idealdir. Örneğin, önce bir metni özetleyen, sonra bu özeti kullanarak bir soruya cevap veren bir zincir oluşturabilirsiniz.
- RetrievalQAChain: Harici belgelerden bilgi alıp, bu bilgilerle soruları cevaplamak için tasarlanmıştır. Bir retriever (bilgi alıcı) ve bir BHM’yi birleştirir.
Chain’ler, uygulamaların mantığını yapılandırmak ve BHM’lerin kapasitesini artırmak için inanılmaz derecede esnek bir yol sunar.
Agentler (Agents) ve Araçlar (Tools): Dinamik Karar Verme ve Dış Dünya ile Etkileşim
Agent’lar, LangChain’in en güçlü ve yenilikçi özelliklerinden biridir. Bir Agent, hangi eylemi yapacağına, hangi aracı kullanacağına ve bu eylemleri hangi sırayla gerçekleştireceğine dinamik olarak karar verebilen bir BHM’dir. Agent’lar, BHM’lerin “düşünmesini” ve karmaşık problemleri çözmek için adım adım akıl yürütmesini sağlar.
- Agent: Bir BHM, bir dizi araç ve bir akıl yürütme döngüsünden oluşur. Kullanıcının sorgusuna dayanarak, mevcut araçlardan hangisinin sorunu çözmek için en iyi olduğunu belirler ve bu aracı kullanır.
- Tools: Agent’ların kullanabileceği işlevlerdir. Bir araç, web araması yapabilir (örneğin Google Search API), bir Python kodu çalıştırabilir, bir API çağırabilir veya bir veritabanını sorgulayabilir. LangChain, birçok yerleşik araç sunar ve kendi özel araçlarınızı oluşturmanızı da kolaylaştırır.
Agent’lar, BHM’lerin sadece metin üretmekle kalmayıp, problemleri çözmek için dış kaynakları kullanmasını ve kendi başına mantıksal adımlar atmasını sağlayarak, BHM uygulamalarının yeteneklerini bir üst seviyeye taşır. Gerçekten akıllı, otonom sistemler oluşturmanın anahtarıdırlar.
Bellek (Memory): Sohbet Bağlamını Koruma
BHM’lerin her etkileşimi tek başına görme eğiliminde olması, sohbet tabanlı uygulamalar için büyük bir sorundur. LangChain’deki “Memory” bileşenleri, önceki etkileşimleri saklayarak ve BHM’ye sunarak bu sorunu çözer. Bu sayede, BHM konuşmanın bağlamını hatırlayabilir ve daha tutarlı, doğal cevaplar verebilir.
- ConversationBufferMemory: En basit bellek türüdür ve tüm konuşma geçmişini bir arabellek içinde saklar.
- ConversationSummaryMemory: Konuşma geçmişinin bir özetini oluşturarak bellek kullanımını azaltır ve uzun sohbetler için daha verimlidir.
- ConversationBufferWindowMemory: Yalnızca son N etkileşimi saklayarak, belirli bir “zaman penceresi” içindeki bağlamı korur.
Bellek, chatbotlar, sanal asistanlar ve uzun süreli etkileşim gerektiren tüm uygulamalar için olmazsa olmaz bir bileşendir.
Belge Yükleyicileri (Document Loaders) ve Retriever’lar (Retrievers): Veri Erişimi ve Geri Getirme
LangChain, BHM’lerin kendi eğitim verilerinin ötesindeki geniş veri kaynaklarına erişmesini sağlamak için çeşitli bileşenler sunar:
- Document Loaders: PDF’ler, web sayfaları, CSV dosyaları, veritabanları gibi farklı kaynaklardan veri yüklemek için kullanılır. Bu yükleyiciler, verileri BHM’lerin işleyebileceği “belge” formatına dönüştürür.
- Text Splitters: Yüklenen belgeleri BHM’lerin bağlam penceresine sığacak daha küçük parçalara (chunks) bölmek için kullanılır.
- Vectorstores: Embedding’leri saklamak ve benzerlik aramaları yapmak için kullanılan veritabanlarıdır. Chroma, Pinecone, FAISS gibi birçok popüler vektör veritabanıyla entegrasyonu vardır.
- Retrievers: Bir sorguya veya bağlama dayalı olarak ilgili belgeleri (genellikle bir Vectorstore’dan) almak için kullanılır. Bu, BHM’ye güncel veya özel bilgiler sunarak “bilgi edinme” yeteneğini büyük ölçüde artırır.
Bu bileşenler, BHM’ler için bilgiye dayalı sistemler oluşturmanın temelini oluşturur; BHM’lerin gerçek zamanlı verilerle veya kurum içi belgelerle çalışmasına olanak tanır.
İlk LangChain Uygulamanızı Adım Adım Nasıl Geliştirirsiniz?
Şimdi teoriden pratiğe geçme zamanı! LangChain ile basit ama işlevsel bir BHM uygulaması geliştirmek için adım adım bir rehber sunacağız. Bu örnekte, belirli bir metin üzerinde soru-cevap yapabilen bir sistem oluşturacağız. Bu, bilgi tabanı uygulamaları, doküman analizi veya müşteri destek sistemleri için temel bir vaka analizi niteliğindedir.
Kurulum ve Temel Ortam Ayarları Nasıl Yapılır?
LangChain kullanmaya başlamak için öncelikle Python ortamınızda gerekli kütüphaneleri kurmanız gerekiyor. Ayrıca, bir BHM sağlayıcısıyla (bu örnekte OpenAI kullanacağız) etkileşim kurmak için API anahtarlarınızı ayarlamanız şarttır.
Adım 1: Gerekli Kütüphaneleri Kurun
Terminalinizi açın ve aşağıdaki komutları çalıştırın:
pip install langchain openai
Bu komut, LangChain framework'ünü ve OpenAI modelleriyle iletişim kurmak için gereken OpenAI Python istemcisini yükleyecektir.
Adım 2: API Anahtarınızı Ayarlayın
OpenAI'den bir API anahtarı almanız gerekecek. Bu anahtarı, ortam değişkeni olarak ayarlamak en güvenli ve önerilen yöntemdir. Birçok işletim sisteminde (Linux/macOS) aşağıdaki komutu kullanabilirsiniz:
export OPENAI_API_KEY="sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
Windows kullanıyorsanız, komut istemcisinde set OPENAI_API_KEY=sk-xxxxxxxxxxxx komutunu veya PowerShell'de $env:OPENAI_API_KEY="sk-xxxxxxxxxxxx" komutunu kullanabilirsiniz. Ya da Python betiğinizin başında doğrudan import os; os.environ["OPENAI_API_KEY"] = "sk-xxxxxxxxxxxx" şeklinde tanımlayabilirsiniz. Ancak üretim ortamlarında bu yöntem önerilmez.
Basit Bir Soru-Cevap Botu Oluşturma Örneği (Vaka Analizi)
Haydi şimdi, verdiğimiz bir metin parçasından belirli soruları cevaplayabilen basit bir BHM destekli sistem oluşturalım. Bu, LangChain'in en temel "Chain" yapısını ve "PromptTemplate" kullanımını gösterecektir.
Problem: Bir şirket hakkında genel bilgiler içeren bir metinimiz var. Bu metinden, şirket faaliyetleri veya geçmişi hakkında soruları cevaplayabilen bir yapay zeka asistanı oluşturmak istiyoruz.
Çözüm Adımları:
- Bir BHM modeli tanımlayacağız (OpenAI GPT-3.5-turbo).
- BHM'ye hangi formatta soru soracağımızı belirten bir "PromptTemplate" oluşturacağız.
- Bu PromptTemplate ve BHM'yi bir "LLMChain" içinde birleştireceğiz.
- Chain'i kullanarak sorular sorup cevaplar alacağız.
Kod Örneği:
from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
import os
# OpenAI API anahtarınızın ortam değişkeni olarak ayarlandığından emin olun
# os.environ["OPENAI_API_KEY"] = "sizin_api_anahtarınız_buraya"
# 1. Bir LLM Modeli Tanımlama
# temperature parametresi, çıktının ne kadar yaratıcı veya belirleyici olacağını ayarlar (0.0-1.0 arası)
llm = OpenAI(temperature=0.7)
# 2. PromptTemplate Oluşturma
# Soru-cevap sistemi için bir bağlam ve bir soru değişkeni içeren bir şablon belirliyoruz.
# "context" değişkeni, botun cevaplayacağı bilgiyi içerecektir.
# "question" değişkeni ise kullanıcının sorusudur.
prompt_template = PromptTemplate(
input_variables=["context", "question"],
template="""Aşağıdaki bağlamı kullanarak soruyu cevaplayın.
Eğer bağlamda bilgi yoksa, 'Üzgünüm, bu bilgiye sahip değilim.' deyin.
Bağlam: {context}
Soru: {question}
Cevap:"""
)
# 3. LLMChain Oluşturma
# PromptTemplate'i ve LLM modelini bir LLMChain içinde birleştiriyoruz.
qa_chain = LLMChain(llm=llm, prompt=prompt_template)
# 4. Bağlam ve Soru Belirleme
# Örnek bağlamımız:
company_context = """
ABC Teknoloji, 2010 yılında kurulmuş, yenilikçi yazılım çözümleri sunan lider bir şirkettir.
Başlangıçta küçük bir mobil uygulama geliştirme stüdyosu olarak yola çıkan şirket,
günümüzde yapay zeka ve bulut bilişim alanlarında öncü projelere imza atmaktadır.
Merkezi İstanbul'da bulunan ABC Teknoloji'nin 200'den fazla çalışanı bulunmaktadır.
Şirketin ana hedeflerinden biri, sürdürülebilir teknolojik gelişmeleri destekleyerek
topluma fayda sağlamaktır.
"""
# İlk soru
question1 = "ABC Teknoloji ne zaman kuruldu?"
print(f"Soru: {question1}")
# Chain'i çağırırken, PromptTemplate'te tanımladığımız input_variables'ı (context ve question) sözlük olarak iletiyoruz.
response1 = qa_chain.run(context=company_context, question=question1)
print(f"Cevap: {response1.strip()}") # strip() ile fazla boşlukları temizliyoruz.
print("-" * 30)
# İkinci soru
question2 = "ABC Teknoloji'nin ana hedefleri nelerdir?"
print(f"Soru: {question2}")
response2 = qa_chain.run(context=company_context, question=question2)
print(f"Cevap: {response2.strip()}")
print("-" * 30)
# Bağlamda olmayan bir soru
question3 = "ABC Teknoloji'nin CEO'su kimdir?"
print(f"Soru: {question3}")
response3 = qa_chain.run(context=company_context, question=question3)
print(f"Cevap: {response3.strip()}")
print("-" * 30)
Yukarıdaki kod bloğu, LangChain'in temel yapı taşları olan LLM, PromptTemplate ve LLMChain'in nasıl bir araya getirilerek basit bir soru-cevap sistemi oluşturulduğunu göstermektedir. llm objesi, OpenAI API'sine yapılan çağrıları yönetirken, prompt_template objesi, BHM'ye gönderilecek metnin yapısını belirler. LLMChain ise bu iki bileşeni birleştirerek, belirli bir bağlam ve soru ile BHM'den cevap alma sürecini soyutlar.
Çıktıyı analiz ettiğimizde, BHM'nin verilen bağlam içindeki bilgileri doğru bir şekilde işleyerek soruları cevapladığını göreceğiz. Bağlamda olmayan bir soru sorulduğunda ise, prompt'ta belirttiğimiz gibi, "Üzgünüm, bu bilgiye sahip değilim." şeklinde bir cevap döndürmesi beklenir. Bu, BHM'nin yalnızca verilen bilgiyle sınırlı kalmasını ve uydurma cevaplar vermemesini sağlamak için önemli bir stratejidir.
Bu basit örnek, LangChain'in modüler yapısının ve BHM'leri bir uygulamaya entegre etme kolaylığının sadece bir başlangıcıdır. Daha karmaşık uygulamalar için bu temel üzerine bellek, agent'lar ve retriever'lar gibi diğer bileşenleri ekleyerek sisteminizi genişletebilirsiniz.
LangChain ile Daha Akıllı ve Karmaşık Sistemler Nasıl Kurulur?
Basit bir soru-cevap botu oluşturduktan sonra, LangChain'in gerçek gücünü ortaya koyan daha gelişmiş özelliklerine odaklanabiliriz: bellek (memory) kullanarak sohbet geçmişini yönetmek ve agent'lar ile araçları kullanarak dinamik etkileşimler sağlamak. Bu iki özellik, BHM destekli uygulamalarınızı çok daha akıllı ve kullanıcı dostu hale getirecektir.
Bellek (Memory) Kullanarak Sohbet Geçmişini Yönetme Nasıl Yapılır?
Önceki örneğimizdeki soru-cevap botu, her soruyu bağımsız olarak ele alıyordu ve önceki etkileşimleri hatırlamıyordu. Gerçek bir sohbet deneyimi için bu yeterli değildir. LangChain'in bellek bileşenleri, BHM'nin sohbetin bağlamını korumasını sağlar. En yaygın bellek türlerinden biri olan ConversationBufferMemory'yi kullanarak bunu nasıl yapacağımıza bakalım.
Problem: Sohbet robotumuzun önceki konuşmaları hatırlamasını ve bu bağlama göre cevap vermesini istiyoruz.
Çözüm: Bir ConversationChain oluşturacağız ve içine bir ConversationBufferMemory ekleyeceğiz.
from langchain.llms import OpenAI
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory
import os
# OpenAI API anahtarınızın ortam değişkeni olarak ayarlandığından emin olun
# os.environ["OPENAI_API_KEY"] = "sizin_api_anahtarınız_buraya"
# 1. Bir LLM Modeli Tanımlama
llm = OpenAI(temperature=0.7)
# 2. Bellek Bileşeni Oluşturma
# ConversationBufferMemory, tüm sohbet geçmişini bir arabellek içinde tutar.
memory = ConversationBufferMemory()
# 3. ConversationChain Oluşturma
# ConversationChain, PromptTemplate'i otomatik olarak yönetir ve memory'yi entegre eder.
# verbose=True, chain'in iç çalışma mantığını (prompt'ları vb.) görmemizi sağlar.
conversation = ConversationChain(
llm=llm,
memory=memory,
verbose=True # Bu, sürecin adımlarını terminalde görmenizi sağlar.
)
# İlk etkileşim
print("Kullanıcı: Merhaba, nasılsın?")
response1 = conversation.predict(input="Merhaba, nasılsın?")
print(f"Bot: {response1.strip()}")
print("-" * 30)
# İkinci etkileşim (önceki bağlamı kullanarak)
print("Kullanıcı: Benim adım Ayşe. Sen kimsin?")
response2 = conversation.predict(input="Benim adım Ayşe. Sen kimsin?")
print(f"Bot: {response2.strip()}")
print("-" * 30)
# Üçüncü etkileşim (hem kendi adını hem de kullanıcının adını hatırlamalı)
print("Kullanıcı: Ayşe ile sohbet etmekten keyif alıyor musun?")
response3 = conversation.predict(input="Ayşe ile sohbet etmekten keyif alıyor musun?")
print(f"Bot: {response3.strip()}")
print("-" * 30)
# Bellekteki geçmişi kontrol etme
print("\nBellek İçeriği:")
print(memory.buffer)
Bu örnekte, ConversationBufferMemory sayesinde BHM, "Ayşe" adını ve daha önceki konuşma akışını hatırlayarak daha tutarlı ve doğal cevaplar verebildi. verbose=True parametresi, BHM'ye gönderilen tam prompt'u (geçmiş sohbeti de içeren) görmenizi sağlar, bu da hata ayıklama ve prompt mühendisliği için çok faydalıdır.
Agentlar ve Araçlarla Dinamik Etkileşim Nasıl Sağlanır?
Bir BHM'nin sadece metin üretmekle kalmayıp, dış dünyayla etkileşime geçmesini, soruları yanıtlamak için kararlar almasını ve uygun araçları kullanmasını istediğimizde "Agent"ları devreye sokarız. Agent'lar, BHM'lerin "düşünmesini" ve karmaşık görevleri çözmek için adımlar atmasını sağlar.
Problem: Kullanıcının hem genel sorularını cevaplayabilen hem de gerçek zamanlı bilgiye (örneğin güncel döviz kuru) ihtiyaç duyduğunda dışarıdan bilgi alabilen bir asistan oluşturmak istiyoruz.
Çözüm: Bir Agent oluşturacağız ve ona bir veya daha fazla "Tool" (araç) sağlayacağız. Bu örnekte, web araması yapabilen bir aracı kullanacağız (örneğin SerpAPI, Google Search API veya DuckDuckGoSearchRun).
Öncelikle, kullanacağımız araca bağlı olarak gerekli ek kütüphaneleri kurmalıyız. Örneğin, serpapi için:
pip install google-search-results
Ve SerpAPI anahtarınızı da ortam değişkeni olarak ayarlamanız gerekir:
export SERPAPI_API_KEY="your-serpapi-api-key"
Şimdi agent örneğimize geçelim:
from langchain.agents import AgentExecutor, create_react_agent
from langchain_openai import OpenAI
from langchain.tools import Tool
from langchain_community.tools import DuckDuckGoSearchRun # SerpAPI yoksa bunu kullanabiliriz
from langchain import hub
import os
# OpenAI ve SerpAPI (veya DuckDuckGoSearchRun için gerekmez) API anahtarlarının ayarlandığından emin olun
# os.environ["OPENAI_API_KEY"] = "sizin_api_anahtarınız_buraya"
# os.environ["SERPAPI_API_KEY"] = "sizin_serpapi_anahtarınız_buraya"
# 1. Bir LLM Modeli Tanımlama
llm = OpenAI(temperature=0) # Agent'lar için genellikle düşük sıcaklık (daha deterministik) tercih edilir.
# 2. Araçları Tanımlama
# Arama aracı oluşturuyoruz. Bu, agent'ın dış dünyadan bilgi edinmesini sağlar.
# SerpAPI yerine DuckDuckGoSearchRun kullanırsanız 'google-search-results' kurulumuna gerek kalmaz.
# search = DuckDuckGoSearchRun() # Eğer SerpAPI kullanmak istemiyorsanız
search_tool = Tool(
name="Search",
func=DuckDuckGoSearchRun().run, # Burada SerpAPIWrapper().run da kullanılabilir
description="Arama motorunu kullanarak güncel bilgilere erişmek için kullanışlıdır."
)
tools = [search_tool]
# 3. Agent Oluşturma
# Agent'ın kullanacağı prompt'u LangChain Hub'dan çekiyoruz. Bu, iyi tasarlanmış bir prompt sağlar.
prompt = hub.pull("hwchase17/react")
# ReAct Agent'ını oluşturuyoruz. ReAct, modelin düşünmesini (thought) ve eylem (action) yapmasını sağlar.
agent = create_react_agent(llm, tools, prompt)
# 4. AgentExecutor Oluşturma
# AgentExecutor, agent'ın çalıştığı runtime'dır. Araçları çağırır ve agent'ın adımlarını yürütür.
agent_executor = AgentExecutor(
agent=agent,
tools=tools,
verbose=True, # Agent'ın düşünme ve eylem adımlarını görmek için True yapın.
handle_parsing_errors=True # Agent'ın çıktılarını ayrıştırmada sorun yaşarsa hata vermesini sağlar.
)
# Agent ile etkileşim
print("Kullanıcı: İstanbul'un nüfusu kaç ve Türkiye'nin başkenti neresidir?")
response1 = agent_executor.invoke({"input": "İstanbul'un nüfusu kaç ve Türkiye'nin başkenti neresidir?"})
print(f"Bot: {response1['output'].strip()}")
print("-" * 30)
print("Kullanıcı: Şu anki dolar kuru nedir?")
response2 = agent_executor.invoke({"input": "Şu anki dolar kuru nedir?"})
print(f"Bot: {response2['output'].strip()}")
print("-" * 30)
Bu agent örneği, BHM'nin sadece öğrendiği verilerle sınırlı kalmadığını, aynı zamanda ihtiyaç duyduğunda dış kaynaklardan (bu durumda bir arama motoru) bilgi alabildiğini gösteriyor. verbose=True sayesinde, agent'ın nasıl düşündüğünü (thought), hangi aracı çağırdığını (action), aracın ne cevap verdiğini (observation) ve nihai cevabı nasıl ürettiğini adım adım takip edebilirsiniz. Bu, agent'ların karmaşık problemler için nasıl çözüm ürettiklerini anlamak açısından çok değerlidir.
Agent'lar ve araçlar, BHM uygulamalarına gerçek dünya etkileşim yeteneği kazandırır. Bu sayede, sadece metin tabanlı değil, aynı zamanda dinamik ve eyleme yönelik asistanlar, otomasyon sistemleri ve veri analiz araçları oluşturabilirsiniz.
LangChain Uygulamalarının Performansı ve Ölçeklenebilirliği Nasıl İyileştirilir?
LangChain ile güçlü BHM uygulamaları geliştirirken, performans ve ölçeklenebilirlik önemli hale gelir. Özellikle üretim ortamında çalışan uygulamalar için bu faktörler kritik öneme sahiptir. İşte uygulamanızın daha hızlı ve daha verimli çalışmasını sağlayacak bazı ipuçları ve mobil uyumluluk hakkında düşünceler:
Uygulama Performansını Artırma Stratejileri
BHM çağrıları genellikle zaman alıcı ve maliyetli olabilir. Performansı artırmak için aşağıdaki teknikleri değerlendirebilirsiniz:
- Caching (Önbellekleme): Aynı sorgu tekrarlandığında BHM'ye tekrar çağrı yapmak yerine, daha önce alınan cevabı önbellekten döndürmek performansı ve maliyeti önemli ölçüde iyileştirebilir. LangChain, çeşitli önbellekleme entegrasyonları sunar (InMemoryCache, RedisCache, SQLiteCache vb.).
from langchain.cache import InMemoryCache
from langchain.globals import set_llm_cache
from langchain.llms import OpenAI
# Bellek içi önbelleği etkinleştir
set_llm_cache(InMemoryCache())
llm = OpenAI(temperature=0)
# Aynı sorguyu birden çok kez çalıştırma
print(llm.invoke("Büyük dil modelleri nedir?"))
print(llm.invoke("Büyük dil modelleri nedir?")) # Bu çağrı önbellekten dönecektir
Bu örnekte ikinci çağrı, OpenAI API'sine gitmek yerine önbellekten servis edilecektir, bu da süreyi ve maliyeti azaltır.
ainvoke (asenkron invoke) veya arun gibi asenkron metodları destekler.Uygulamanın Ölçeklenebilirliğini Sağlama
Uygulamanız büyüdükçe, daha fazla kullanıcıya ve daha karmaşık isteklere hizmet verebilmesi için ölçeklenebilir olması gerekir:
- Durumsuz (Stateless) Mimariler: Uygulamanızın mümkün olduğunca durumsuz olmasını sağlamak, yük dengeleyiciler arkasında kolayca yatay ölçeklenmesine olanak tanır. Bellek gibi durum gerektiren bileşenler için Redis gibi harici, ölçeklenebilir bellek depolarını kullanın.
- Kapsayıcılaştırma (Containerization): Uygulamanızı Docker gibi araçlarla kapsayıcılara almak, farklı ortamlarda tutarlı bir şekilde çalışmasını sağlar ve Kubernetes gibi orkestrasyon araçlarıyla kolayca ölçeklendirilebilir.
- İzleme ve Günlükleme (Monitoring & Logging): Uygulamanızın performansını, hata oranlarını ve BHM çağrılarını izlemek için araçlar kullanın. LangChain, tracing (izleme) araçlarıyla (örneğin LangSmith) entegrasyonlar sunar. Bu, üretim ortamında sorunları hızlıca tespit etmenizi ve çözmenizi sağlar.
Mobil Uyumlu HTML ve Kullanıcı Deneyimi
LangChain, backend'de BHM mantığını yöneten bir framework'tür. Frontend (kullanıcı arayüzü) tarafında ise HTML, CSS ve JavaScript kullanarak mobil uyumlu deneyimler oluşturabilirsiniz. Bir web arayüzü geliştiriyorsanız, responsive tasarım prensiplerini uygulamak kritik öneme sahiptir.
Örnek Mobil Uyumlu CSS Yapısı (HTML çıktısı içerisinde yer almasa da, bu konuyu açıklamak adına buraya eklenmiştir):
/* Genel stil tanımlamaları */
body {
font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
margin: 0;
padding: 20px;
background-color: #f4f7f6;
color: #333;
}
.chat-container {
max-width: 800px;
margin: 20px auto;
background-color: #ffffff;
border-radius: 8px;
box-shadow: 0 4px 10px rgba(0, 0, 0, 0.1);
display: flex;
flex-direction: column;
min-height: 400px;
}
.chat-messages {
flex-grow: 1;
padding: 20px;
overflow-y: auto;
border-bottom: 1px solid #eee;
}
.message {
margin-bottom: 15px;
padding: 10px 15px;
border-radius: 20px;
max-width: 70%;
word-wrap: break-word;
}
.user-message {
background-color: #007bff;
color: white;
margin-left: auto;
border-bottom-right-radius: 0;
}
.bot-message {
background-color: #e2e6ea;
color: #333;
margin-right: auto;
border-bottom-left-radius: 0;
}
.chat-input {
display: flex;
padding: 15px;
border-top: 1px solid #eee;
}
.chat-input input[type="text"] {
flex-grow: 1;
border: 1px solid #ccc;
border-radius: 20px;
padding: 10px 15px;
font-size: 1rem;
outline: none;
}
.chat-input button {
background-color: #28a745;
color: white;
border: none;
border-radius: 20px;
padding: 10px 20px;
margin-left: 10px;
cursor: pointer;
font-size: 1rem;
transition: background-color 0.3s ease;
}
.chat-input button:hover {
background-color: #218838;
}
/* Mobil cihazlar için medya sorguları */
@media (max-width: 768px) {
body {
padding: 10px;
}
.chat-container {
margin: 0;
border-radius: 0;
box-shadow: none;
min-height: calc(100vh - 20px); /* Ekran yüksekliğine uyum sağla */
}
.message {
max-width: 85%; /* Daha küçük ekranlarda mesaj genişliğini artır */
}
.chat-input {
flex-direction: column; /* Giriş alanını ve düğmeyi dikeyde hizala */
}
.chat-input button {
margin-left: 0;
margin-top: 10px;
width: 100%; /* Düğmeyi tam genişlik yap */
padding: 12px;
}
}
Bu CSS kodu, bir sohbet arayüzünün büyük ekranlarda nasıl görüneceğini ve @media (max-width: 768px) medya sorgusu sayesinde daha küçük ekranlarda (tabletler ve akıllı telefonlar) nasıl adapte olacağını göstermektedir. Mobil uyumlu bir kullanıcı deneyimi, BHM uygulamanızın geniş kitlelere ulaşması ve etkili olması için hayati öneme sahiptir. LangChain, backend mantığını sağlamlaştırırken, frontend geliştiricileri bu mantığı mobil uyumlu arayüzlere sorunsuz bir şekilde entegre edebilirler.
Sonuç: LangChain ile Geleceğe Yönelik Uygulamalar Geliştirin
LangChain, Büyük Dil Modelleri'nin (BHM) gücünü kullanarak akıllı ve etkileşimli uygulamalar geliştirmek isteyen herkes için paha biçilmez bir araçtır. Bu makalede, LangChain'in ne olduğundan, neden bu kadar önemli olduğuna, temel bileşenlerinden adım adım ilk uygulamanızı nasıl geliştireceğinize ve son olarak da performans ile ölçeklenebilirlik ipuçlarına kadar geniş bir yelpazede bilgi edindiniz. LangChain, karmaşık BHM entegrasyonlarını basitleştirerek, bellek yönetimi, araç kullanımı ve çok adımlı zincirleme gibi gelişmiş yetenekleri kolayca uygulamanıza olanak tanır.
LangChain sayesinde, sadece metin üreten botlardan çok daha fazlasını inşa edebilirsiniz. Dış dünyadan bilgi alabilen, geçmiş sohbetleri hatırlayan, karmaşık görevleri planlayıp yürütebilen ve hatta kendi başına karar verebilen "akıllı agent"lar yaratabilirsiniz. Bu yetenekler, müşteri hizmetlerinden veri analizine, içerik üretiminden kişiselleştirilmiş öğrenme ortamlarına kadar sayısız alanda devrim niteliğinde uygulamaların kapılarını aralamaktadır.
Yapay zeka teknolojileri hızla gelişmeye devam ederken, LangChain gibi framework'ler, bu gelişmeleri pratik uygulamalara dönüştürme sürecini demokratikleştirmektedir. Geliştiricilere karmaşık BHM dünyasında yol gösteren bir harita sunarak, yenilikçi fikirlerini gerçeğe dönüştürmeleri için sağlam bir temel oluşturur. Unutmayın ki, BHM'ler sadece bir başlangıç noktasıdır; gerçek değer, onları akıllıca birleştirip gerçek dünya problemlerine uyguladığınızda ortaya çıkar. LangChain ile bu yolculuğa güvenle çıkabilirsiniz.
Sıkça Sorulan Sorular (SSS)
1. LangChain öğrenmek için hangi ön bilgilere ihtiyacım var?
Temel Python bilgisi ve Büyük Dil Modelleri'nin (BHM) nasıl çalıştığına dair genel bir anlayış, LangChain'i öğrenmek için iyi bir başlangıç noktasıdır. Detaylı BHM teorisi bilmenize gerek yoktur, ancak API'lerle çalışmaya aşina olmak süreci kolaylaştıracaktır.
2. LangChain hangi BHM'leri destekliyor?
LangChain, OpenAI, Hugging Face, Google (PaLM), Cohere, Anthropic gibi birçok farklı BHM sağlayıcısını destekler. Ayrıca, yerel olarak çalışan veya özel olarak eğitilmiş BHM'lerle de entegrasyon imkanı sunar. Modüler yapısı sayesinde yeni modelleri entegre etmek de oldukça kolaydır.
3. LangChain tamamen ücretsiz mi? Kullandığımda bir maliyet oluşur mu?
LangChain framework'ünün kendisi açık kaynaklı ve ücretsizdir. Ancak, OpenAI gibi ticari BHM sağlayıcılarının API'lerini kullandığınızda, bu sağlayıcıların belirlediği kullanım ücretleri (token bazında veya kullanım miktarına göre) ortaya çıkacaktır. Açık kaynaklı BHM'leri (örneğin Hugging Face Hub'dan) kullanarak veya kendi makinelerinizde barındırarak maliyeti düşürebilirsiniz, ancak bu durumda kendi altyapı maliyetleriniz olacaktır.
4. LangChain'in ana rakipleri veya alternatifleri nelerdir?
LangChain'in doğrudan rakipleri olmamakla birlikte, benzer işlevsellikler sunan farklı framework'ler ve kütüphaneler mevcuttur. Örneğin, LlamaIndex (veri indeksleme ve alma odaklı), Haystack (bilgi geri getirme ve BHM boru hatları), Semantic Kernel (Microsoft tarafından .NET ve Python için BHM orkestrasyonu) gibi kütüphaneler LangChain ile benzer alanlarda çözümler sunar. Ancak LangChain, genel amaçlı bir BHM uygulama geliştirme framework'ü olarak oldukça kapsamlıdır.
5. LangChain ile gerçek dünya uygulamaları geliştirilebilir mi?
Kesinlikle! LangChain, gerçek dünya senaryolarına yönelik birçok gelişmiş özellik sunar. Chatbotlar, soru-cevap sistemleri, belge özetleyiciler, akıllı arama motorları, kod üreteçleri, sanal asistanlar ve çok daha fazlası LangChain ile geliştirilebilir. Özellikle harici veri kaynaklarıyla entegrasyon ve dinamik karar verme yetenekleri sayesinde, LangChain ile inşa edilen uygulamaların potansiyeli oldukça geniştir.