LangChain Performans Optimizasyonu: 15 İleri Teknik [2026 Rehberi]

# LangChain Performans Optimizasyonu: 15 İleri Teknik [2026 Rehberi] Günümüzün yapay zeka odaklı dünyasında, akıllı uygulamaların başarısı büyük ölçüde performanslarına bağlıdır. Peki, LangChain tabanlı uygulamalarınızın yavaş çalışması kullanıcı deneyiminizi baltalıyor mu? Endişelenmeyin! Bu kapsamlı rehberde, 2026 itibarıyla LangChain uygulamalarınızın **performansını zirveye taşıyacak 15 kanıtlanmış ileri teknik** ile tanışacak, API gecikmelerini nasıl azaltacağınızı, token maliyetlerini nasıl düşüreceğinizi ve genel sistem verimliliğini nasıl artıracağınızı adım adım öğreneceksiniz. Kendi üretim ortamımda LangChain ile geliştirdiğim projelerde karşılaştığım darboğazları aşmak için uyguladığım stratejileri ve 2026'nın en güncel yaklaşımlarını bu yazıda bulacaksınız. ## LangChain Nedir? LangChain, büyük dil modelleri (LLM'ler) ile çalışan uygulamalar geliştirmek için tasarlanmış, esnek ve modüler bir çerçevedir. 2026 itibarıyla, geliştiricilerin LLM'leri harici veri kaynaklarıyla entegre etmesini, aracıları (agents) kullanarak karmaşık görevleri otomatize etmesini ve zincirleme (chaining) yöntemleriyle daha sofistike iş akışları oluşturmasını sağlayan popüler bir araç setidir. Python ve JavaScript/TypeScript dillerinde mevcut olan LangChain, LLM'lerin potansiyelini tam olarak kullanmak isteyen herkes için vazgeçilmez bir köprü görevi görür. LangChain, sadece LLM'lerle etkileşimi kolaylaştırmakla kalmaz, aynı zamanda veri alma (retrieval), bellek yönetimi (memory management), aracı oluşturma (agent creation) ve araç entegrasyonu (tool integration) gibi temel yapı taşlarını sunarak, geliştiricilerin karmaşık LLM uygulamalarını daha hızlı ve verimli bir şekilde inşa etmelerine olanak tanır. Özellikle 2026'da giderek artan LLM kullanım senaryolarında, LangChain'in sunduğu soyutlama katmanı, geliştirme sürecini basitleştirir ve üretim ortamına hazır çözümler üretmeyi hızlandırır. ## Neden LangChain Performans Optimizasyonu Yapmalısınız? LangChain, LLM uygulamaları geliştirmeyi kolaylaştırsa da, varsayılan kurulumlar genellikle performans darboğazlarına yol açabilir. Neden optimizasyona odaklanmanız gerektiğini maddeler halinde inceleyelim: * **Maliyet Azaltma:** LLM API çağrıları token bazında ücretlendirilir. Optimize edilmemiş zincirler gereksiz token kullanımına yol açar, bu da maliyetleri ciddi şekilde artırır. Performans optimizasyonu ile token kullanımını minimize ederek bulut faturanızı düşürebilirsiniz. * **Yanıt Süresi İyileştirme:** Kullanıcılar hızlı yanıtlar bekler. Gecikmeler, kullanıcı deneyimini olumsuz etkiler ve uygulamanızın benimsenmesini azaltır. Optimize edilmiş bir LangChain uygulaması, saniyeler içinde yanıt vererek kullanıcı memnuniyetini artırır. * **Ölçeklenebilirlik:** Yüksek trafikli uygulamalar için performans kritik öneme sahiptir. Optimize edilmiş bir mimari, aynı kaynaklarla daha fazla isteği işleyebilir, bu da uygulamanızın daha ölçeklenebilir olmasını sağlar. * **Kaynak Verimliliği:** Daha az CPU, bellek ve ağ kullanımı, daha düşük operasyonel maliyetler anlamına gelir. Bu, özellikle üretim ortamında sürekli çalışan servisler için büyük bir avantajdır. * **Sürdürülebilirlik:** Verimli çalışan sistemler, daha az enerji tüketir. Bu, hem çevresel etkiyi azaltır hem de uzun vadede maliyet tasarrufu sağlar. Ekibimizde LangChain'e geçiş sürecinde, ilk prototiplerimizin yanıt sürelerinin beklenenin çok üzerinde olduğunu gördük. Bu durum, özellikle gerçek zamanlı sohbet botları ve otomatik içerik üretim sistemleri için kabul edilemezdi. Kapsamlı bir optimizasyon süreciyle, ortalama yanıt süremizi %60 oranında azaltarak kullanıcı memnuniyetini önemli ölçüde artırdık. ## LangChain vs. Alternatifler (2026 Karşılaştırması) LangChain, LLM orkestrasyonu alanında popülerliğini korurken, başka çerçeveler de mevcuttur. 2026 itibarıyla en yaygın alternatiflerle karşılaştıralım: | Özellik | LangChain (Python/JS) | LlamaIndex (Python) | Semantic Kernel (C#/Python/Java) | | :------------------ | :-------------------------------------------------- | :--------------------------------------------------- | :--------------------------------------------------- | | **Performans** | Modüler yapısıyla yüksek optimizasyon potansiyeli. | Veri indeksleme ve RAG için optimize edilmiş. | Microsoft ekosistemiyle entegre, kurumsal odaklı. | | **Öğrenme Eğrisi** | Orta. Geniş API yüzeyi, ancak iyi dokümantasyon. | Orta. RAG odaklı, belirli use-case'lerde daha kolay. | Orta. Microsoft geliştiricileri için daha tanıdık. | | **Ekosistem** | Geniş ve aktif topluluk, birçok entegrasyon. | RAG ve veri yönetimi için güçlü araçlar. | Kurumsal entegrasyonlar, Azure AI servisleri. | | **Topluluk** | Çok büyük ve sürekli gelişen. | Hızla büyüyen, RAG odaklı. | Microsoft geliştirici topluluğu tarafından desteklenir. | | **Kurumsal Destek** | Açık kaynak, ücretli destek şirketleri mevcut. | Açık kaynak, ücretli destek şirketleri mevcut. | Microsoft tarafından desteklenir. | | **Kullanım Alanı** | Genel LLM orkestrasyonu, ajanlar, zincirler. | Veri alımı destekli üretim (RAG) uygulamaları. | Kurumsal AI çözümleri, Copilot benzeri uygulamalar. | **Yorum:** 2026 itibarıyla LangChain, genel LLM uygulama geliştirme için en esnek ve kapsamlı çözümlerden biri olmaya devam ediyor. Özellikle karmaşık ajan sistemleri ve çok adımlı zincirler oluşturmak isteyenler için idealdir. LlamaIndex, veri alımı ve RAG (Retrieval Augmented Generation) konusunda derinlemesine optimizasyonlar sunarken, Semantic Kernel daha çok Microsoft ekosistemine entegre kurumsal çözümler için tercih edilmektedir. Performans açısından, her üçü de doğru kullanıldığında yüksek verimlilik sağlayabilir, ancak LangChain'in modülerliği, detaylı optimizasyonlara daha fazla olanak tanır. ## Kurulum ve İlk Adımlar (2026 Sürümü) LangChain performans optimizasyonuna başlamadan önce, güncel bir kurulum yapmak önemlidir. 2026 itibarıyla LangChain'in kararlı sürümü `v0.1.x` veya `v0.2.x` aralığında olabilir. Bu rehberde, `v0.1.x` serisinden bir sürüm kullandığımızı varsayalım. **Ön Gereksinimler:** * Python 3.9+ kurulu olmalı. * `pip` paket yöneticisi güncel olmalı. * Bir LLM sağlayıcısından API anahtarı (örn. OpenAI, Google Gemini). 1. **Sanal Ortam Oluşturma ve Aktivasyon:** Performans testleri ve bağımlılık yönetimi için sanal ortam kullanmak en iyi pratiktir. ```bash python -m venv langchain-perf-env source langchain-perf-env/bin/activate # Linux/macOS # langchain-perf-env\Scripts\activate # Windows ``` 2. **LangChain ve Gerekli Kütüphaneleri Kurma:** LLM sağlayıcınız için gerekli kütüphaneyi de kurmayı unutmayın. Bu örnekte OpenAI kullanacağız. ```bash pip install langchain==0.1.x # 2026 itibarıyla güncel kararlı sürüm pip install openai==1.x.x # 2026 itibarıyla güncel kararlı sürüm pip install python-dotenv # API anahtarlarını güvenli yönetmek için ``` 3. **API Anahtarını Yapılandırma:** `.env` dosyası oluşturarak API anahtarınızı güvenli bir şekilde saklayın. ```dotenv # .env dosyası OPENAI_API_KEY='sizin_openai_api_anahtarınız' ``` 4. **İlk Basit Zincir Oluşturma ve Test Etme:** `main.py` adında bir dosya oluşturup aşağıdaki kodu ekleyin. ```python # main.py from dotenv import load_dotenv import os from langchain_openai import ChatOpenAI from langchain.chains import LLMChain from langchain.prompts import PromptTemplate load_dotenv() # LLM'i başlat llm = ChatOpenAI(temperature=0.7, model_name="gpt-4o-2026-04-23") # 2026'nın güncel modeli varsayımı # Prompt şablonu oluştur prompt = PromptTemplate( input_variables=["konu"], template="{konu} hakkında kısa ve bilgilendirici bir açıklama yap." ) # Zinciri oluştur chain = LLMChain(llm=llm, prompt=prompt) # Zinciri çalıştır print("LangChain ile ilk çağrı yapılıyor...") response = chain.invoke({"konu": "Kuantum Bilgisayarları"}) print(response["text"]) ``` 5. **Uygulamayı Çalıştırma:** ```bash python main.py ``` Bu adımlar, LangChain ile çalışmaya başlamak için temel bir ortam sağlar. Şimdi performans optimizasyon tekniklerine geçebiliriz. ## Temel Kullanım ve Örnekler (Performans Odaklı) Performans optimizasyonuna girmeden önce, LangChain'in temel yapılarını verimli kullanmanın önemini vurgulayalım. Her bir örnekte, başlangıçta dikkat edilmesi gereken performans ipuçlarına yer vereceğim. ### Örnek 1: Basit LLM Çağrısı (Model Seçimi) **Problem:** En uygun LLM modelini seçmeden yapılan çağrılar, gereksiz maliyet ve gecikmeye neden olabilir. **Çözüm:** Görevin karmaşıklığına uygun en küçük ve en hızlı modeli seçin. Örneğin, basit özetleme için `gpt-3.5-turbo-2026-04-23` (varsayılan 2026 modeli) yeterli olabilirken, karmaşık akıl yürütme için `gpt-4o-2026-04-23` tercih edilebilir. ```python from langchain_openai import ChatOpenAI # Yüksek performanslı, maliyet etkin model (basit görevler için) fast_llm = ChatOpenAI(temperature=0.0, model_name="gpt-3.5-turbo-2026-04-23") # Daha yetenekli, ancak daha yavaş ve pahalı model (karmaşık görevler için) smart_llm = ChatOpenAI(temperature=0.7, model_name="gpt-4o-2026-04-23") # Örnek kullanım print(f"Fast LLM yanıtı: {fast_llm.invoke('JavaScript nedir?').content}") print(f"Smart LLM yanıtı: {smart_llm.invoke('Kuantum bilgisayarları ve yapay zeka arasındaki potansiyel sinerjiyi açıklayın.').content}") ``` ### Örnek 2: Zincirleme (Chain) Oluşturma (Minimalist Yaklaşım) **Problem:** Gereksiz yere karmaşık zincirler oluşturmak, her adımda ek gecikme ve işlem yükü yaratır. **Çözüm:** Mümkün olduğunca az adım içeren, doğrudan amaca hizmet eden zincirler tasarlayın. `LCEL (LangChain Expression Language)` ile daha verimli zincirler oluşturabilirsiniz. ```python from langchain_openai import ChatOpenAI from langchain.prompts import ChatPromptTemplate from langchain_core.output_parsers import StrOutputParser llm = ChatOpenAI(model_name="gpt-3.5-turbo-2026-04-23", temperature=0) # Basit bir prompt şablonu prompt_template = ChatPromptTemplate.from_messages([ ("system", "Sen bir teknoloji uzmanısın."), ("user", "{konu} hakkında kısa bir özet yap.") ]) # LCEL kullanarak verimli zincir summarize_chain = prompt_template | llm | StrOutputParser() # Zinciri çalıştır print(f"Özet: {summarize_chain.invoke({'konu': 'Büyük Dil Modelleri'})}") ``` ### Örnek 3: Veri Alımı Destekli Üretim (RAG) (Chunking Optimizasyonu) **Problem:** Yanlış `chunk` boyutu veya `chunk` stratejisi, alakasız parçaların alınmasına veya önemli bilgilerin kaçırılmasına yol açar, bu da LLM'in daha fazla token kullanmasına veya yanlış yanıtlar üretmesine neden olur. **Çözüm:** `RecursiveCharacterTextSplitter` gibi akıllı bölücüler kullanarak, anlamsal bütünlüğü koruyan `chunk`'lar oluşturun ve `chunk_size` ile `chunk_overlap` değerlerini dikkatlice ayarlayın. ```python from langchain_community.document_loaders import TextLoader from langchain_text_splitters import RecursiveCharacterTextSplitter from langchain_openai import OpenAIEmbeddings from langchain_community.vectorstores import Chroma from langchain.chains import RetrievalQA from langchain_openai import ChatOpenAI # Örnek bir metin dosyası oluştur with open("data.txt", "w") as f: f.write("LangChain, LLM uygulamaları geliştirmek için bir çerçevedir. \n") f.write("Performans optimizasyonu maliyetleri düşürür ve yanıt sürelerini iyileştirir.\n") f.write("2026'da LangChain, geniş bir topluluğa sahiptir.") # Dokümanı yükle loader = TextLoader("data.txt") documents = loader.load() # Metni parçalara ayır (optimize edilmiş chunking) # chunk_size: LLM'in bağlam penceresine uygun, anlamsal bütünlüğü koruyacak şekilde. # chunk_overlap: Parçalar arası geçişi sağlayarak bağlam kaybını önler. text_splitter = RecursiveCharacterTextSplitter(chunk_size=100, chunk_overlap=20) texts = text_splitter.split_documents(documents) # Embedding modelini başlat embeddings = OpenAIEmbeddings(model="text-embedding-3-small") # 2026 itibarıyla verimli model # Vektör veritabanı oluştur ve dokümanları ekle vectorstore = Chroma.from_documents(texts, embeddings) retriever = vectorstore.as_retriever() # RAG zinciri oluştur qa_chain = RetrievalQA.from_chain_type( llm=ChatOpenAI(model_name="gpt-3.5-turbo-2026-04-23"), chain_type="stuff", retriever=retriever ) # Sorgu yap question = "LangChain neden önemlidir?" response = qa_chain.invoke({"query": question}) print(f"Soru: {question}\nYanıt: {response['result']}") ``` ### Örnek 4: Paralel İşleme (Async/Await) **Problem:** Birden fazla bağımsız LLM çağrısı veya harici API isteği sırayla yapıldığında, toplam yanıt süresi artar. **Çözüm:** Python'ın `asyncio` kütüphanesini ve LangChain'in asenkron API'lerini kullanarak paralel çağrılar yapın. ```python import asyncio from langchain_openai import ChatOpenAI from langchain.prompts import ChatPromptTemplate llm = ChatOpenAI(model_name="gpt-3.5-turbo-2026-04-23", temperature=0) async def get_response_async(prompt_text): prompt = ChatPromptTemplate.from_messages([("user", prompt_text)]) chain = prompt | llm return await chain.ainvoke({}) async def main_async(): tasks = [ get_response_async("Python'ın en popüler 3 kütüphanesi nedir?"), get_response_async("JavaScript'in en popüler 3 framework'ü nedir?"), get_response_async("Bulut bilişimin avantajları nelerdir?") ] responses = await asyncio.gather(*tasks) for i, res in enumerate(responses): print(f"Soru {i+1} Yanıt: {res.content}") if __name__ == "__main__": asyncio.run(main_async()) ``` ## İleri Seviye Teknikler (Performans Odaklı) LangChain uygulamalarınızdan maksimum verim almak için bazı ileri seviye teknikleri uygulamanız gerekebilir. Bu teknikler genellikle daha karmaşık senaryolar ve üretim ortamları için kritik öneme sahiptir. ### 1. Prompt Mühendisliği ve Az Token Kullanımı **Problem:** Kötü tasarlanmış prompt'lar, LLM'in gereksiz yere uzun yanıtlar üretmesine veya bağlamı yanlış anlamasına neden olur, bu da hem maliyeti hem de gecikmeyi artırır. **Çözüm:** Prompt'larınızı kısa, net ve doğrudan olacak şekilde tasarlayın. Örnekler vererek LLM'i yönlendirin (few-shot prompting). Gereksiz talimatlardan kaçının ve LLM'den sadece ihtiyacınız olan formatta yanıt isteyin (JSON, anahtar-değer çiftleri vb.). ```python from langchain_openai import ChatOpenAI from langchain.prompts import ChatPromptTemplate from langchain_core.output_parsers import JsonOutputParser from langchain_core.pydantic_v1 import BaseModel, Field # Çıktı formatını tanımlayan Pydantic modeli class UserSummary(BaseModel): name: str = Field(description="Kullanıcının adı") age: int = Field(description="Kullanıcının yaşı") occupation: str = Field(description="Kullanıcının mesleği") parser = JsonOutputParser(pydantic_object=UserSummary) # Prompt'ta formatı belirtme ve örnek verme prompt = ChatPromptTemplate.from_messages([ ("system", "Sen bir veri çıkarma uzmanısın. Kullanıcı bilgilerini JSON formatında çıkar."), ("user", "Aşağıdaki metinden kullanıcı adını, yaşını ve mesleğini çıkar:\n\nMetin: 'Merhaba, ben Ayşe Yılmaz. 30 yaşındayım ve yazılım mühendisiyim.'\nFormat: {format_instructions}\n\nMetin: '{text}'") ]).partial(format_instructions=parser.get_format_instructions()) llm = ChatOpenAI(model_name="gpt-3.5-turbo-2026-04-23", temperature=0) chain = prompt | llm | parser user_data = "Adım Mehmet Can, 45 yaşındayım ve bir proje yöneticisiyim." result = chain.invoke({"text": user_data}) print(result) # Output: {'name': 'Mehmet Can', 'age': 45, 'occupation': 'proje yöneticisi'} ``` Bu yöntem, LLM'in daha az 'düşünmesini' ve doğrudan istenen formatta yanıt vermesini sağlayarak token ve zaman tasarrufu sağlar. ### 2. Akıllı Caching (Önbellekleme) **Problem:** Aynı LLM çağrılarının tekrar tekrar yapılması, gereksiz API maliyetleri ve gecikmeler yaratır. **Çözüm:** LangChain'in yerleşik önbellekleme mekanizmalarını veya Redis gibi harici önbellek sistemlerini kullanarak daha önce yapılmış LLM çağrılarının yanıtlarını saklayın ve tekrar kullanın. Bu, özellikle sıkça sorulan sorular veya sabit veri kümeleri için çok etkilidir. ```python from langchain_openai import ChatOpenAI from langchain.globals import set_llm_cache from langchain_community.cache import InMemoryCache, RedisCache import redis import os # 1. Bellek içi önbellek (geliştirme ve test için uygun) # set_llm_cache(InMemoryCache()) # 2. Redis önbellek (üretim için önerilir) # Redis sunucusunun çalıştığından emin olun. # redis_client = redis.Redis(host='localhost', port=6379, db=0) # set_llm_cache(RedisCache(redis_client=redis_client)) llm = ChatOpenAI(model_name="gpt-3.5-turbo-2026-04-23", temperature=0) print("İlk çağrı (önbellek yoksa yavaş)") response1 = llm.invoke("Türkiye'nin başkenti neresidir?") print(f"Yanıt 1: {response1.content}") print("İkinci çağrı (önbellekten gelecek, hızlı)") response2 = llm.invoke("Türkiye'nin başkenti neresidir?") print(f"Yanıt 2: {response2.content}") # Önbelleği temizle (opsiyonel) # set_llm_cache(None) ``` ### 3. Paralel İşleme ve Asenkron API'ler **Problem:** Bağımsız LLM çağrılarını veya araç kullanımlarını sırayla yapmak, toplam yanıt süresini uzatır. **Çözüm:** `asyncio` ve LangChain'in `ainvoke`, `abatch` gibi asenkron metodlarını kullanarak birden fazla işlemi eş zamanlı olarak yürütün. Bu, özellikle birden fazla aracıyla etkileşim kuran veya birden fazla LLM çağrısı yapan ajanlar için kritiktir. ```python import asyncio from langchain_openai import ChatOpenAI from langchain.prompts import ChatPromptTemplate llm = ChatOpenAI(model_name="gpt-3.5-turbo-2026-04-23", temperature=0) async def get_summary(topic): prompt = ChatPromptTemplate.from_template("'{topic}' hakkında kısa bir özet yap.") chain = prompt | llm return await chain.ainvoke({"topic": topic}) async def main_parallel_summaries(): topics = ["Yapay Zeka", "Makine Öğrenimi", "Derin Öğrenme"] tasks = [get_summary(topic) for topic in topics] results = await asyncio.gather(*tasks) for topic, result in zip(topics, results): print(f"Konu: {topic}\nÖzet: {result.content[:100]}...") if __name__ == "__main__": asyncio.run(main_parallel_summaries()) ``` ### 4. Batched İşleme (Toplu İşleme) **Problem:** Küçük, tekil LLM çağrıları yapmak, her çağrı için ağ gecikmesi ve API overhead'i yaratır. **Çözüm:** Birden fazla bağımsız isteği tek bir toplu çağrıda birleştirin. LangChain'in `batch` metodları, bu tür senaryolarda performansı artırabilir. LLM sağlayıcınızın toplu işleme yeteneklerini de kontrol edin. ```python from langchain_openai import ChatOpenAI from langchain.prompts import ChatPromptTemplate llm = ChatOpenAI(model_name="gpt-3.5-turbo-2026-04-23", temperature=0) prompt = ChatPromptTemplate.from_template("'{topic}' hakkında 20 kelimelik bir özet yap.") chain = prompt | llm # Tekil çağrılar # for topic in ["Güneş Sistemi", "Kara Delikler"]: # print(chain.invoke({"topic": topic}).content) # Toplu çağrılar (daha verimli) responses = chain.batch([{"topic": "Güneş Sistemi"}, {"topic": "Kara Delikler"}]) for i, res in enumerate(responses): print(f"Konu {i+1} Özet: {res.content}") ``` ### 5. Akışlı Yanıtlar (Streaming) **Problem:** LLM'den tam yanıtın gelmesini beklemek, kullanıcıya uzun bir bekleme süresi yaşatır. **Çözüm:** Özellikle sohbet botları gibi interaktif uygulamalarda, LLM yanıtlarını kelime kelime veya token token akışlı olarak almak, kullanıcı algılanan gecikmeyi azaltır. LangChain'in `stream` metodu bu işlevselliği sağlar. ```python from langchain_openai import ChatOpenAI from langchain.prompts import ChatPromptTemplate llm = ChatOpenAI(model_name="gpt-3.5-turbo-2026-04-23", temperature=0, streaming=True) prompt = ChatPromptTemplate.from_template("Yapay zekanın geleceği hakkında 50 kelimelik bir deneme yaz.") chain = prompt | llm print("Akışlı yanıt geliyor:") for chunk in chain.stream({}): print(chunk.content, end="", flush=True) print("\n(Akış tamamlandı)") ``` ### 6. Geri Alma (Retrieval) Optimizasyonu (K-Değeri ve Filtreleme) **Problem:** RAG sistemlerinde, alakasız veya çok fazla doküman parçası almak, LLM'in bağlam penceresini gereksiz yere doldurur, performansı düşürür ve maliyeti artırır. **Çözüm:** `retriever`'ınızın `k` değerini (kaç doküman parçası alınacağı) optimize edin. Ayrıca, metadata filtreleme kullanarak sadece ilgili dokümanları alın. 2026'da gelişmiş vektör veritabanları bu filtreleme yeteneklerini daha da ileri taşımıştır. ```python from langchain_community.document_loaders import TextLoader from langchain_text_splitters import RecursiveCharacterTextSplitter from langchain_openai import OpenAIEmbeddings from langchain_community.vectorstores import Chroma from langchain.chains import RetrievalQA from langchain_openai import ChatOpenAI # Örnek dokümanlar (metadata ile) documents = [ {"page_content": "LangChain, LLM orkestrasyonu için bir Python kütüphanesidir.", "metadata": {"source": "langchain_docs", "year": 2024}}, {"page_content": "Performans optimizasyonu, maliyetleri ve gecikmeyi azaltır.", "metadata": {"source": "seo_blog", "year": 2026}}, {"page_content": "Retrieval Augmented Generation (RAG) LLM'lere harici bilgi sağlar.", "metadata": {"source": "ai_paper", "year": 2025}} ] # Dokümanları parçalara ayır text_splitter = RecursiveCharacterTextSplitter(chunk_size=100, chunk_overlap=0) texts = text_splitter.create_documents( [doc["page_content"] for doc in documents], metadatas=[doc["metadata"] for doc in documents] ) embeddings = OpenAIEmbeddings(model="text-embedding-3-small") vectorstore = Chroma.from_documents(texts, embeddings) # k=2 ile retriever oluştur (sadece en alakalı 2 dokümanı al) # metadata filtreleme ile sadece 2026'dan sonraki kaynakları al retriever_optimized = vectorstore.as_retriever(search_kwargs={ "k": 2, "filter": {"year": {"$gte": 2026}} # 2026 ve sonrası kaynakları filtrele }) qa_chain_optimized = RetrievalQA.from_chain_type( llm=ChatOpenAI(model_name="gpt-3.5-turbo-2026-04-23"), chain_type="stuff", retriever=retriever_optimized ) question = "RAG ne işe yarar ve 2026 kaynaklarından bilgi ver?" response = qa_chain_optimized.invoke({"query": question}) print(f"Soru: {question}\nYanıt: {response['result']}") ``` ### 7. Agent Tasarımı ve Araç Seçimi **Problem:** Gereksiz araçlar veya kötü tasarlanmış ajanlar, LLM'in karar verme sürecini yavaşlatır ve gereksiz adımlar atmasına neden olur. **Çözüm:** Ajanlarınıza sadece gerçekten ihtiyaç duydukları araçları verin. `tool_code` veya `tool_spec` gibi parametrelerle araçlarınızı daha spesifik hale getirin. `AgentExecutor`'ın `max_iterations` ve `early_stopping_method` parametrelerini ayarlayarak sonsuz döngüleri ve gereksiz denemeleri önleyin. Özellikle 2026'da `self-correction` yetenekleri gelişmiş ajanlar daha verimli çalışır. ```python from langchain.agents import AgentExecutor, create_react_agent, tool from langchain_openai import ChatOpenAI from langchain.prompts import PromptTemplate # Örnek bir araç tanımla @tool def get_current_weather(location: str) -> str: "Belirtilen konumdaki güncel hava durumunu döndürür." if "İstanbul" in location: return "İstanbul'da hava açık ve 25 derece." elif "Ankara" in location: return "Ankara'da parçalı bulutlu ve 20 derece." else: return "Bilinmeyen konum için hava durumu bilgisi yok." # Sadece gerekli araçları ajana ver tools = [get_current_weather] # Ajan için prompt oluştur prompt = PromptTemplate.from_template("Yanıtlaman gereken soru: {input}") llm = ChatOpenAI(model_name="gpt-3.5-turbo-2026-04-23", temperature=0) # ReAct ajanı oluştur agent = create_react_agent(llm, tools, prompt) # AgentExecutor'ı oluştur ve iterasyon limitini ayarla # max_iterations: Ajanın maksimum kaç adım atabileceğini belirler. # early_stopping_method: Ajanın ne zaman duracağını belirler ('force' veya 'generate'). agent_executor = AgentExecutor( agent=agent, tools=tools, verbose=True, max_iterations=5, # Maksimum 5 adımda dur early_stopping_method="generate" ) # Ajanı çalıştır result = agent_executor.invoke({"input": "İstanbul'da hava nasıl?"}) print(result["output"]) ``` ### 8. Token Gözetimi ve Yönetimi **Problem:** LLM'lere gönderilen prompt'ların ve alınan yanıtların token boyutunu izlememek, beklenmedik maliyet artışlarına ve `context window` hatalarına yol açar. **Çözüm:** LangChain'in callback'lerini kullanarak token kullanımını izleyin. `tiktoken` gibi kütüphanelerle prompt'unuzu LLM'e göndermeden önce token sayısını tahmin edin ve gerekirse prompt'u kısaltın veya özetleyin. ```python from langchain_openai import ChatOpenAI from langchain.callbacks import get_openai_callback llm = ChatOpenAI(model_name="gpt-3.5-turbo-2026-04-23", temperature=0) with get_openai_callback() as cb: response = llm.invoke("Yapay zekanın etik boyutları hakkında detaylı bir deneme yaz.") print(f"Yanıt: {response.content[:100]}...") print(f"\nToplam Token: {cb.total_tokens}") print(f"Giriş Token: {cb.prompt_tokens}") print(f"Çıkış Token: {cb.completion_tokens}") print(f"Toplam Maliyet: ${cb.total_cost:.4f}") ``` ### 9. Prompt ve Zincir Sıkıştırma (Prompt Compression) **Problem:** Uzun prompt'lar veya geçmiş konuşma metinleri, LLM bağlam penceresini doldurur ve token maliyetlerini artırır. **Çözüm:** `LLMChainExtractor` veya `LongContextReorder` gibi LangChain modüllerini kullanarak geçmiş konuşmaları özetleyin veya prompt içindeki gereksiz bilgileri çıkarın. `Contextual Compression Retriever` ile sadece en alakalı bilgileri LLM'e iletin. ```python from langchain.retrievers import ContextualCompressionRetriever from langchain.retrievers.document_compressors import LLMChainExtractor from langchain_openai import OpenAIEmbeddings, ChatOpenAI from langchain_community.vectorstores import Chroma from langchain_core.documents import Document # Örnek dokümanlar docs = [ Document(page_content="LangChain'in en yeni sürümü 2026'da çıktı."), Document(page_content="Python ile geliştirilen LangChain, LLM uygulamaları için kullanılır."), Document(page_content="Performans optimizasyonu, LangChain'in verimliliğini artırır.") ] # Embedding ve vektör veritabanı embeddings = OpenAIEmbeddings(model="text-embedding-3-small") vectorstore = Chroma.from_documents(docs, embeddings) base_retriever = vectorstore.as_retriever() # LLM tabanlı kompresör llm_compressor = LLMChainExtractor(llm=ChatOpenAI(model_name="gpt-3.5-turbo-2026-04-23", temperature=0)) # ContextualCompressionRetriever oluştur compression_retriever = ContextualCompressionRetriever(base_compressor=llm_compressor, base_retriever=base_retriever) # Sıkıştırılmış dokümanları al compressed_docs = compression_retriever.get_relevant_documents("LangChain'in performansı nasıl artırılır?") for doc in compressed_docs: print(f"Sıkıştırılmış Doküman: {doc.page_content}") ``` ### 10. Gelişmiş Bellek Yönetimi **Problem:** Uzun süreli sohbetlerde geçmiş konuşmaların tamamını LLM'e göndermek, bağlam penceresini aşar ve maliyeti artırır. **Çözüm:** `ConversationSummaryBufferMemory` veya `ConversationTokenBufferMemory` gibi LangChain'in gelişmiş bellek türlerini kullanarak geçmişi özetleyin veya token limitine göre kırpın. Bu, bağlamı korurken maliyeti ve gecikmeyi azaltır. ```python from langchain.chains import ConversationChain from langchain_openai import ChatOpenAI from langchain.memory import ConversationSummaryBufferMemory llm = ChatOpenAI(model_name="gpt-3.5-turbo-2026-04-23", temperature=0) # token_limit: Belleğin tutabileceği maksimum token sayısı. memory = ConversationSummaryBufferMemory(llm=llm, max_token_limit=100) conversation = ConversationChain( llm=llm, memory=memory, verbose=True ) conversation.predict(input="Merhaba, ben bir yazılım geliştiricisiyim.") conversation.predict(input="En sevdiğim programlama dili Python.") conversation.predict(input="Python ile yapay zeka projeleri geliştiriyorum.") conversation.predict(input="Peki sen ne yapabilirsin?") print("\nBellek içeriği (özetlenmiş olabilir):") print(memory.load_memory_variables({})) ``` ### 11. LLM Gateway Kullanımı **Problem:** Farklı LLM sağlayıcıları arasında geçiş yapmak veya maliyet/performans metriklerini merkezi olarak yönetmek zor olabilir. **Çözüm:** LiteLLM, Portkey.ai veya kendi özel LLM gateway'inizi kullanarak LLM çağrılarını yönlendirin, önbellekleyin, maliyetleri izleyin ve yük dengelemesi yapın. Bu, özellikle büyük ölçekli ve çok modelli uygulamalar için kritiktir. 2026'da LLM gateway'leri, güvenlik ve uyumluluk özellikleriyle de öne çıkıyor. ```python # LiteLLM veya Portkey.ai gibi bir gateway kütüphanesi kullanarak # Bu örnek doğrudan LangChain ile entegrasyonu göstermez, # ancak konsepti açıklar. # pip install litellm # from litellm import completion # response = completion( # model="gpt-3.5-turbo-2026-04-23", # messages=[{"role": "user", "content": "Hello"}], # caching=True, # Gateway seviyesinde önbellekleme # # Diğer gateway ayarları (maliyet izleme, yük dengeleme vb.) # ) # print(response.choices[0].message.content) ``` ### 12. Gelişmiş Prompt Routing ve Fallback Mekanizmaları **Problem:** Tek bir LLM'e veya tek bir prompt stratejisine bağlı kalmak, performans veya maliyet açısından optimal olmayabilir. **Çözüm:** `RouterChain` gibi mekanizmalarla, gelen sorguları analiz ederek farklı LLM'lere, farklı prompt'lara veya hatta farklı zincirlere yönlendirin. Daha basit görevler için daha ucuz/hızlı modelleri, karmaşık görevler için daha yetenekli modelleri kullanın. Ayrıca, bir LLM başarısız olduğunda başka bir LLM'e geçiş yapan `fallback` me