LangChain: 7 Adımda Kapsamlı Başlangıç [2026 Rehberi]
Yazar: Burak Balkı | Kategori: Backend Development | Okuma Süresi: 54 dk
Bu 2026 rehberi, LangChain'i sıfırdan öğrenmek isteyen geliştiriciler için hazırlandı. Adım adım kurulumdan ileri seviye tekniklere, kod örnekleriyle çalışan...
# LangChain: 7 Adımda Kapsamlı Başlangıç [2026 Rehberi]
Bugün, Büyük Dil Modelleri (LLM'ler) ve yapay zeka teknolojileri, yazılım geliştirme dünyasında devrim yaratmaya devam ediyor. Ancak, bu modellerin gücünü tam anlamıyla kullanacak, ölçeklenebilir ve güvenilir uygulamalar geliştirmek karmaşık bir süreç olabilir. İşte tam da bu noktada **LangChain**, geliştiricilere bu karmaşıklığı aşmak için güçlü ve esnek bir çerçeve sunuyor. Bu 2026 rehberinde, LangChain'in temel prensiplerinden başlayarak, adım adım çalışan bir yapay zeka projesi oluşturma yolculuğuna çıkacağız. Hemen şimdi LangChain ile LLM uygulamaları geliştirmenin inceliklerini öğrenmeye başlayın!
## LangChain Nedir?
LangChain, Büyük Dil Modelleri (LLM'ler) ile çalışan uygulamalar oluşturmak için tasarlanmış, açık kaynaklı bir geliştirme çerçevesidir. Temel olarak, LLM'leri harici veri kaynakları ve işlem mantığı ile birleştirerek, modellerin tek başına yapamayacağı karmaşık görevleri yerine getirmesini sağlar. Geliştiricilerin, modüler bileşenler aracılığıyla prompt mühendisliği, hafıza yönetimi, ajanlar (agents) ve zincirler (chains) gibi gelişmiş LLM konseptlerini kolayca uygulamasına olanak tanır. LangChain, 2026 itibarıyla yapay zeka tabanlı uygulamalar geliştiren herkes için vazgeçilmez bir araç haline gelmiştir.
LangChain'in mimarisi, LLM'lerin yeteneklerini genişletmek ve onları daha işlevsel hale getirmek üzerine kuruludur. Bu çerçeve, LLM'leri yalnızca metin üretme aracı olmaktan çıkarıp, gerçek dünya problemlerini çözebilen, bağlamsal farkındalığı olan ve dış dünya ile etkileşime girebilen akıllı sistemler oluşturmak için bir temel sunar. Özellikle karmaşık iş akışlarını otomatikleştirmek, veri analizi yapmak, akıllı chatbotlar veya Retrieval-Augmented Generation (RAG) sistemleri kurmak isteyen geliştiriciler için idealdir. LangChain, modüler yapısı sayesinde farklı LLM sağlayıcıları (OpenAI, Google Gemini, Anthropic Claude vb.), vektör veritabanları (Chroma, Pinecone) ve diğer araçlarla kolayca entegre olabilir.
## Neden LangChain Kullanmalısınız?
LangChain, LLM tabanlı uygulama geliştirme sürecini önemli ölçüde hızlandıran ve basitleştiren bir dizi avantaj sunar. Production ortamında LLM'lerle çalışırken karşılaştığım en yaygın sorunlardan biri, modellerin sınırlı bağlam penceresi ve güncel bilgi eksikliğiydi. LangChain, RAG (Retrieval-Augmented Generation) gibi tekniklerle bu sorunları aşmamızı sağladı. Son projemde LangChain'i kullanarak, müşteri hizmetleri chatbotumuzun bilgi tabanını dinamik olarak güncelleyebildik ve %30 daha doğru yanıtlar elde ettik.
* **Hızlı Geliştirme ve Prototipleme:** LangChain'in zengin bileşen kütüphanesi, karmaşık LLM iş akışlarını günler yerine saatler içinde oluşturmanıza olanak tanır. Modüler yapısı sayesinde, farklı bileşenleri bir araya getirerek hızla prototipler geliştirebilirsiniz.
* **Modülerlik ve Esneklik:** Chain'ler, Agent'lar, PromptTemplate'ler ve Memory gibi bileşenler tamamen modülerdir. Bu, uygulamanızın belirli ihtiyaçlarına göre özelleştirme yapmanızı ve farklı LLM'leri, vektör veritabanlarını veya araçları kolayca değiştirmenizi sağlar.
* **Entegrasyon Kolaylığı:** LangChain, OpenAI, Google Gemini, Anthropic gibi popüler LLM sağlayıcılarının yanı sıra, SerpAPI, Wikipedia, SQL veritabanları ve çeşitli vektör veritabanları gibi yüzlerce harici araç ve veri kaynağıyla hazır entegrasyonlar sunar.
* **Karmaşık Akışları Yönetme:** Chain'ler ve Agent'lar sayesinde, birden fazla LLM çağrısı gerektiren, karar verme mekanizmaları içeren veya harici araçları kullanan karmaşık görevleri yapılandırılmış bir şekilde yönetebilirsiniz. Bu, özellikle çok adımlı chatbotlar veya otonom ajanlar geliştirirken kritik öneme sahiptir.
* **Maliyet ve Performans Optimizasyonu:** LangChain, token kullanımını optimize etmeye yönelik mekanizmalar (örn. Caching, Prompt Engineering teknikleri) sunar. Ayrıca, LangSmith gibi araçlarla LLM çağrılarınızı izleyerek ve hata ayıklayarak maliyetleri düşürmenize ve performansı artırmanıza yardımcı olur.
LangChain, özellikle LLM'lerin sınırlı bağlam penceresi, güncel bilgi eksikliği ve deterministik olmayan davranışları gibi temel problemlerini çözmek için tasarlanmıştır. Yeni başlayanlardan deneyimli makine öğrenimi mühendislerine kadar geniş bir kitleye hitap eder. Ekibimizde LangChain'e geçiş sürecinde öğrendiğimiz 3 kritik ders, doğru prompt mühendisliğinin ve modüler tasarımın, ölçeklenebilir ve sürdürülebilir LLM uygulamaları için temel olduğuydu. LangChain, 2026 itibarıyla milyonlarca indirme ve aktif bir toplulukla sektör standardı haline gelmiştir.
## LangChain vs Alternatifler
LLM tabanlı uygulama geliştirme ekosistemi hızla büyürken, LangChain'in yanı sıra başka güçlü alternatifler de bulunmaktadır. Bu bölümde, LangChain'i LlamaIndex ve Haystack gibi önde gelen diğer çerçevelerle karşılaştırarak, her birinin güçlü ve zayıf yönlerini inceleyeceğiz. Bu karşılaştırma, projenizin ihtiyaçlarına en uygun aracı seçmenize yardımcı olacaktır.
| Özellik | LangChain | LlamaIndex | Haystack |
|:-------------------|:-----------------------------------------------|:-----------------------------------------------|:-------------------------------------------------|
| **Ana Odak** | LLM uygulamaları için genel amaçlı framework | Veri artırılmış LLM uygulamaları (RAG) | Arama ve soru-cevap sistemleri için end-to-end |
| **Performans** | Modüler yapısı ile optimize edilebilir | Veri indeksleme ve sorgulama odaklı hızlı RAG | Optimize edilmiş arama ve retriever performansı |
| **Öğrenme Eğrisi** | Orta (çok sayıda bileşen) | Orta (veri indeksleme detayları) | Orta (pipeline tabanlı) |
| **Ekosistem** | Geniş (LLM'ler, araçlar, vektör DB'ler) | Veri kaynakları ve vektör DB'ler ağırlıklı | Arama motorları ve retriever'lar odaklı |
| **Topluluk** | Çok aktif ve büyük | Aktif ve büyüyen | Aktif |
| **Kurumsal Destek**| LangChain tarafından LangSmith ile desteklenir | Kurumsal çözümler ve danışmanlık mevcut | Deepset tarafından ticari destek mevcut |
| **Kullanım Alanı** | Chatbotlar, Agent'lar, RAG, veri analizi | Soru-cevap, bilgi çıkarma, veri özetleme | Kurumsal arama, belge analizi, Soru-Cevap |
LangChain, LLM uygulamaları için en esnek ve genel amaçlı çerçeve olarak öne çıkarken, LlamaIndex özellikle Retrieval-Augmented Generation (RAG) senaryolarında veri indeksleme ve sorgulama konusunda derinlemesine optimizasyonlar sunar. Haystack ise arama ve soru-cevap sistemleri için daha bütünsel, uçtan uca bir çözüm sunar. Seçiminiz, projenizin spesifik gereksinimlerine, veri yapınıza ve geliştirme ekibinizin tercihlerine bağlı olacaktır. Genel bir LLM uygulama çatısı arıyorsanız LangChain, veri odaklı RAG için LlamaIndex, arama motoru benzeri sistemler için Haystack güçlü seçeneklerdir.
## Kurulum ve İlk Adımlar
LangChain ile çalışmaya başlamak oldukça basittir. Bu bölümde, gerekli ön gereksinimleri karşılayacak ve ilk basit LangChain uygulamanızı çalıştıracaksınız. Bu adımları takip ederek, 2026'nın güncel kurulum yöntemlerini uygulayacağız.
### Ön Gereksinimler
Başlamadan önce aşağıdaki araçların sisteminizde kurulu olduğundan emin olun:
* **Python 3.11 veya üzeri:** LangChain, Python'ın modern sürümleriyle en iyi performansı sunar. Terminalinizde `python --version` komutunu çalıştırarak sürümünüzü kontrol edebilirsiniz.
* **pip:** Python paket yöneticisi. Genellikle Python ile birlikte gelir.
* **Bir Kod Düzenleyici/IDE:** VS Code, PyCharm veya tercih ettiğiniz herhangi bir metin düzenleyici.
* **OpenAI API Anahtarı:** Örneklerde OpenAI modellerini kullanacağız. Bir anahtarınız yoksa, OpenAI web sitesinden edinebilirsiniz.
### Adım 1: Python Sürümünü Kontrol Etme
Terminalinizi açın ve Python sürümünüzü kontrol edin:
```bash
python --version
# Beklenen çıktıya benzer: Python 3.11.7
```
Eğer Python 3.11 veya üzeri kurulu değilse, resmi Python web sitesinden güncel sürümü indirip kurmanız önerilir.
### Adım 2: Sanal Ortam Oluşturma
Projeleriniz için sanal ortamlar kullanmak iyi bir alışkanlıktır. Bu, bağımlılık çakışmalarını önler.
```bash
mkdir langchain-ilk-proje-2026
cd langchain-ilk-proje-2026
python -m venv venv
source venv/bin/activate # macOS/Linux
# venv\Scripts\activate # Windows
```
Terminalinizin başında `(venv)` gördüğünüzde sanal ortamınız aktif demektir.
### Adım 3: LangChain ve Gerekli Kütüphaneleri Kurma
Şimdi LangChain kütüphanesini ve OpenAI modelini kullanmak için `openai` paketini kuralım. Ayrıca, ortam değişkenlerini yönetmek için `python-dotenv` kullanacağız.
```bash
pip install langchain openai python-dotenv
```
### Adım 4: API Anahtarını Ayarlama (.env)
OpenAI API anahtarınızı doğrudan kodunuza yazmak yerine, `.env` dosyası kullanarak güvenli bir şekilde yönetin. Proje dizininizin kökünde `.env` adında bir dosya oluşturun ve içine anahtarınızı ekleyin:
```dotenv
# .env dosyası
OPENAI_API_KEY="sizin_openai_api_anahtarınız_buraya"
```
> **PRO TIP:** `.env` dosyanızı `.gitignore`'a ekleyerek versiyon kontrol sistemine yüklenmesini engelleyin. Bu, hassas bilgilerinizi güvende tutmanın kritik bir adımıdır.
### Adım 5: İlk LangChain Uygulamasını Çalıştırma
`main.py` adında yeni bir dosya oluşturun ve aşağıdaki kodu içine yapıştırın:
```python
# main.py
from dotenv import load_dotenv
import os
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
# .env dosyasını yükle
load_dotenv()
# OpenAI API anahtarını ortam değişkeninden al
openai_api_key = os.getenv("OPENAI_API_KEY")
# LLM modelini başlat (2026 itibarıyla güncel bir model)
llm = ChatOpenAI(api_key=openai_api_key, model="gpt-4o-2026-05-02") # Varsayımsal 2026 modeli
# Bir prompt şablonu oluştur
prompt = ChatPromptTemplate.from_messages([
("system", "Sen deneyimli bir yazılım geliştiricisinin asistanısın. Kısa ve öz cevaplar ver."),
("user", "{question}")
])
# Çıktı ayrıştırıcı
output_parser = StrOutputParser()
# Chain oluştur
chain = prompt | llm | output_parser
# Chain'i çalıştır
response = chain.invoke({"question": "LangChain'in temel amacı nedir?"})
print(response)
response_2 = chain.invoke({"question": "Python'da sanal ortam neden kullanılır?"})
print(response_2)
```
Şimdi bu dosyayı terminalde çalıştırın:
```bash
python main.py
```
Çıktı olarak, LLM'in sorularınıza verdiği yanıtları görmelisiniz. Tebrikler! İlk LangChain uygulamanızı başarıyla çalıştırdınız. Bu basit örnek, LangChain'in temel bileşenleri olan `PromptTemplate`, `LLM` ve `OutputParser`'ı nasıl bir araya getirebileceğinizi gösteriyor. Bu modüler yapı, daha karmaşık uygulamalar geliştirmenin anahtarıdır.
## Temel Kullanım ve Örnekler
LangChain'in gücü, farklı bileşenleri bir araya getirerek karmaşık iş akışları oluşturabilmesinde yatar. Bu bölümde, gerçek dünya senaryolarına yönelik temel LangChain kullanım örneklerini inceleyeceğiz. Her örnekte, bir problemle başlayıp, LangChain ile nasıl bir çözüm geliştireceğimizi ve ilgili kod örneklerini göstereceğiz.
### Örnek 1: Basit Bir Chain Oluşturma (Prompt + LLM)
**Problem:** Kullanıcıdan alınan bir soruya göre bir teknoloji terimini tanımlayan basit bir LLM uygulaması oluşturmak.
**Çözüm:** `ChatPromptTemplate` ve `ChatOpenAI` kullanarak bir `RunnableSequence` (chain) oluşturacağız. Bu, LangChain Expression Language (LCEL) ile modern ve esnek bir yaklaşımdır.
```python
# example_1_simple_chain.py
from dotenv import load_dotenv
import os
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
load_dotenv()
openai_api_key = os.getenv("OPENAI_API_KEY")
llm = ChatOpenAI(api_key=openai_api_key, model="gpt-4o-2026-05-02", temperature=0.7)
prompt = ChatPromptTemplate.from_messages([
("system", "Sen teknoloji konusunda uzman bir eğitmensin. Kısa ve açıklayıcı tanımlar yap."),
("user", "{terim} nedir?")
])
output_parser = StrOutputParser()
chain = prompt | llm | output_parser
print("--- LangChain Tanımı ---")
response = chain.invoke({"terim": "LangChain"})
print(response)
print("\n--- RAG Tanımı ---")
response_2 = chain.invoke({"terim": "RAG (Retrieval-Augmented Generation)"})
print(response_2)
```
### Örnek 2: Yapılandırılmış Çıktı Ayrıştırma (Structured Output Parsing)
**Problem:** LLM'den belirli bir JSON formatında (örneğin, bir ürünün adı ve fiyatı) bilgi almak.
**Çözüm:** `PydanticOutputParser` veya `JsonOutputParser` kullanarak LLM'in çıktısını programatik olarak kullanabileceğimiz yapılandırılmış bir formata dönüştüreceğiz.
```python
# example_2_structured_output.py
from dotenv import load_dotenv
import os
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.pydantic_v1 import BaseModel, Field
from langchain_core.output_parsers import PydanticOutputParser
load_dotenv()
openai_api_key = os.getenv("OPENAI_API_KEY")
llm = ChatOpenAI(api_key=openai_api_key, model="gpt-4o-2026-05-02", temperature=0)
# Çıktı formatını tanımlayan Pydantic modeli
class ProductInfo(BaseModel):
name: str = Field(description="Ürünün adı")
price: float = Field(description="Ürünün fiyatı (TL)")
currency: str = Field(description="Para birimi kodu (örn. TRY)")
parser = PydanticOutputParser(pydantic_object=ProductInfo)
prompt = ChatPromptTemplate.from_messages([
("system", "Sen ürün bilgilerini JSON formatında döndüren bir asistansın.\n{format_instructions}"),
("user", "{product_description}")
]).partial(format_instructions=parser.get_format_instructions())
chain = prompt | llm | parser
product_description = "En yeni akıllı telefon, 256GB depolama, 25.999 TL."
product_info = chain.invoke({"product_description": product_description})
print("--- Parsed Product Info ---")
print(f"Ürün Adı: {product_info.name}")
print(f"Fiyat: {product_info.price} {product_info.currency}")
# Farklı bir örnek
product_description_2 = "Yüksek performanslı dizüstü bilgisayar, 16GB RAM, 34.500 TL."
product_info_2 = chain.invoke({"product_description": product_description_2})
print(f"\nÜrün Adı: {product_info_2.name}")
print(f"Fiyat: {product_info_2.price} {product_info_2.currency}")
```
### Örnek 3: Hafıza Yönetimi (Memory) ile Sohbet Botu
**Problem:** LLM'lerin önceki konuşmaları hatırlamasını sağlayarak daha doğal ve bağlamsal bir sohbet deneyimi sunmak.
**Çözüm:** `ConversationBufferMemory` kullanarak sohbet geçmişini saklayacağız ve bunu bir `RunnableWithMessageHistory` ile chain'e entegre edeceğiz.
```python
# example_3_memory_chatbot.py
from dotenv import load_dotenv
import os
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables import RunnableWithMessageHistory
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.messages import HumanMessage, AIMessage
load_dotenv()
openai_api_key = os.getenv("OPENAI_API_KEY")
llm = ChatOpenAI(api_key=openai_api_key, model="gpt-4o-2026-05-02", temperature=0.7)
prompt = ChatPromptTemplate.from_messages([
("system", "Sen bir teknoloji danışmanısın. Kullanıcı sorularına dostça ve bilgilendirici cevaplar ver."),
MessagesPlaceholder(variable_name="history"), # Sohbet geçmişi buraya eklenecek
("user", "{question}")
])
chain = prompt | llm
# Sohbet geçmişini saklamak için bir sınıf (örneğin, bir veritabanı yerine basit bir sözlük)
# Gerçek uygulamalarda Redis, PostgreSQL gibi kalıcı depolama kullanılmalıdır.
store = {}
def get_session_history(session_id: str) -> ChatMessageHistory:
if session_id not in store:
store[session_id] = ChatMessageHistory()
return store[session_id]
with_message_history = RunnableWithMessageHistory(
chain, get_session_history, input_messages_key="question", history_messages_key="history"
)
config = {"configurable": {"session_id": "burak_session_1"}}
print("--- Sohbet Başladı ---")
response_1 = with_message_history.invoke({"question": "Bana yapay zeka hakkında bilgi verebilir misin?"}, config=config)
print(f"AI: {response_1.content}")
response_2 = with_message_history.invoke({"question": "Peki, Machine Learning ile arasındaki fark nedir?"}, config=config)
print(f"AI: {response_2.content}")
response_3 = with_message_history.invoke({"question": "Bu konularda 2026'daki en güncel trendler neler?"}, config=config)
print(f"AI: {response_3.content}")
print("\n--- Sohbet Geçmişi ---")
print(store["burak_session_1"].messages)
```
### Örnek 4: Document Loading ve Vektör Veritabanları (RAG)
**Problem:** LLM'in eğitim verilerinde olmayan, özel bir belge hakkında soru cevaplamak.
**Çözüm:** Bir metin dosyasını `TextLoader` ile yükleyeceğiz, `RecursiveCharacterTextSplitter` ile parçalara ayıracağız, `OpenAIEmbeddings` ile embedding'lerini oluşturacağız ve `Chroma` vektör veritabanına kaydedip sorgulayacağız. Bu, Retrieval-Augmented Generation (RAG) mimarisinin temelidir.
Önce gerekli kütüphaneleri kuralım:
```bash
pip install unstructured pypdf chromadb tiktoken
```
`data/teknoloji_raporu_2026.txt` adında bir dosya oluşturalım:
```text
# data/teknoloji_raporu_2026.txt
2026 Teknoloji Trendleri Raporu
Bu rapor, 2026 yılındaki en önemli teknoloji trendlerini incelemektedir. Yapay zeka, özellikle üretken yapay zeka (Generative AI) ve Büyük Dil Modelleri (LLM'ler), sektörler arası dönüşümün ana itici gücü olmaya devam etmektedir. Özellikle LangChain gibi framework'ler, bu modellerin iş uygulamalarına entegrasyonunu hızlandırmıştır.
Kuantum hesaplama alanındaki gelişmeler, teorik olmaktan çıkıp pratik uygulamalara doğru ilerlemektedir. Siber güvenlik, özellikle yapay zeka destekli saldırı ve savunma mekanizmalarıyla yeni bir boyut kazanmıştır. Edge computing ve 5G teknolojileri, IoT cihazlarının veri işleme kapasitesini artırarak daha akıllı şehirler ve endüstriyel otomasyon çözümlerini mümkün kılmaktadır.
Sürdürülebilir teknoloji çözümleri, enerji verimliliği ve yeşil bilişim 2026'da büyük önem taşımaktadır. Blockchain teknolojisi, merkeziyetsiz finansın ötesine geçerek tedarik zinciri yönetimi ve dijital kimlik doğrulama gibi alanlarda yaygınlaşmaktadır.
Metaverse ve Web3 kavramları, kullanıcı deneyimini zenginleştiren yeni platformlar sunmaktadır. Geliştiriciler, Python ve TypeScript gibi dillerde, modern bulut altyapıları üzerinde bu teknolojileri inşa etmektedirler.
```
Şimdi Python kodunu yazalım:
```python
# example_4_rag.py
from dotenv import load_dotenv
import os
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.document_loaders import TextLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import Chroma
from langchain.chains.combine_documents import create_stuff_documents_chain
from langchain_core.prompts import ChatPromptTemplate
from langchain.chains import create_retrieval_chain
load_dotenv()
openai_api_key = os.getenv("OPENAI_API_KEY")
# 1. Dokümanı Yükle
loader = TextLoader("data/teknoloji_raporu_2026.txt")
docs = loader.load()
# 2. Dokümanı Parçalara Ayır
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = text_splitter.split_documents(docs)
# 3. Embedding'leri Oluştur ve Vektör Veritabanına Kaydet
embeddings = OpenAIEmbeddings(api_key=openai_api_key)
vectorstore = Chroma.from_documents(chunks, embeddings)
# 4. Retriever Oluştur
retriever = vectorstore.as_retriever()
# 5. LLM ve Prompt Oluştur
llm = ChatOpenAI(api_key=openai_api_key, model="gpt-4o-2026-05-02")
prompt = ChatPromptTemplate.from_template(
"""Sadece sağlanan bağlamı kullanarak aşağıdaki soruyu cevapla.
Eğer cevabı bağlamda bulamıyorsan, 'Üzgünüm, bu bilgiyi sağlanan belgelerde bulamıyorum.' de.
Bağlam: {context}
Soru: {input}"""
)
document_chain = create_stuff_documents_chain(llm, prompt)
# 6. Retrieval Chain Oluştur
retrieval_chain = create_retrieval_chain(retriever, document_chain)
# 7. Sorguyu Çalıştır
print("--- RAG Sorgusu ---")
response = retrieval_chain.invoke({"input": "2026'da yapay zeka alanındaki ana itici güçler nelerdir?"})
print(f"Cevap: {response['answer']}")
response_2 = retrieval_chain.invoke({"input": "Kuantum hesaplama hakkında ne gibi gelişmeler bekleniyor?"})
print(f"Cevap: {response_2['answer']}")
response_3 = retrieval_chain.invoke({"input": "Bana LangChain'in ne olduğunu anlatır mısın?"})
print(f"Cevap: {response_3['answer']}") # Bu bilgi raporda geçiyor
response_4 = retrieval_chain.invoke({"input": "2026'da Mars'a insanlı yolculuk yapılacak mı?"})
print(f"Cevap: {response_4['answer']}") # Bu bilgi raporda geçmiyor
```
### Örnek 5: Agent ve Tool Kullanımı (Web Arama)
**Problem:** LLM'in güncel bilgilere erişememesi sorununu aşmak ve harici araçları kullanarak daha dinamik cevaplar üretmesini sağlamak.
**Çözüm:** `Agent` kullanarak LLM'e bir `Tool` (örneğin, web arama aracı SerpAPI) sağlayacağız. Bu, LLM'in bir soruyu cevaplamak için kendi başına karar verip, gerekli durumlarda harici bir aracı kullanmasını sağlayacak.
Önce SerpAPI anahtarınızı `.env` dosyasına ekleyin ve gerekli kütüphaneyi kurun:
```dotenv
# .env dosyası
OPENAI_API_KEY="sizin_openai_api_anahtarınız_buraya"
SERPAPI_API_KEY="sizin_serpapi_anahtarınız_buraya"
```
```bash
pip install google-search-results
```
Şimdi Python kodunu yazalım:
```python
# example_5_agent_tool.py
from dotenv import load_dotenv
import os
from langchain_openai import ChatOpenAI
from langchain import hub
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_community.tools import SerpAPIWrapper
from langchain_core.tools import Tool
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
load_dotenv()
openai_api_key = os.getenv("OPENAI_API_KEY")
serpapi_api_key = os.getenv("SERPAPI_API_KEY")
llm = ChatOpenAI(api_key=openai_api_key, model="gpt-4o-2026-05-02", temperature=0)
# SerpAPI aracını oluştur
search = SerpAPIWrapper(serpapi_api_key=serpapi_api_key)
tools = [
Tool(
name="SerpAPI_Search",
func=search.run,
description="Güncel olaylar ve genel bilgiler için internette arama yapmak için kullanışlıdır."
)
]
# Agent prompt'unu LangChain Hub'dan çek (veya kendimiz oluşturabiliriz)
# 2026 itibarıyla güncel prompt'lar için hub'a bakmak en doğrusu.
# prompt = hub.pull("hwchase17/openai-functions-agent") # Bu prompt'u direkt kullanmak yerine,
# daha güncel bir prompt veya kendi prompt'umuzu oluşturalım.
prompt = ChatPromptTemplate.from_messages([
("system", "Sen bir yardımcı yapay zeka ajanısın. Güncel bilgilere ihtiyacın olduğunda araçları kullan."),
MessagesPlaceholder(variable_name="chat_history", optional=True),
("human", "{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad")
])
# Agent oluştur
agent = create_openai_functions_agent(llm, tools, prompt)
# Agent Executor oluştur
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
print("--- Agent ile Sorgu ---")
response = agent_executor.invoke({"input": "2026 UEFA Şampiyonlar Ligi finali nerede oynanacak?"})
print(f"AI Cevabı: {response['output']}")
print("\n--- Agent ile Sorgu 2 ---")
response_2 = agent_executor.invoke({"input": "LangChain'in en güncel kararlı sürümü nedir?"})
print(f"AI Cevabı: {response_2['output']}")
```
## İleri Seviye Teknikler
LangChain'in temel kullanımlarını anladıktan sonra, daha karmaşık ve production'a hazır uygulamalar geliştirmek için ileri seviye tekniklere geçebiliriz. Bu bölüm, deneyimli geliştiricilere yönelik olup, LangChain'in daha derin özelliklerini ve mimari desenlerini keşfedecektir.
### 1. LangChain Expression Language (LCEL) ile Karmaşık Chain'ler
LCEL, LangChain'in 2026 itibarıyla en güçlü özelliklerinden biridir. Chain'leri, boru hatlarını (pipelines) ve paralel işlemleri deklaratif ve okunabilir bir şekilde tanımlamanızı sağlar. Bu, hata ayıklamayı kolaylaştırır ve performans optimizasyonuna olanak tanır.
**Örnek: Paralel İşlem ve Fallback Mekanizması**
Birden fazla LLM'i paralel çalıştırmak ve birinin hata vermesi durumunda diğerine geçmek (fallback) için LCEL kullanabiliriz. Bu, uygulamanızın dayanıklılığını artırır.
```python
# advanced_lcel_fallback.py
from dotenv import load_dotenv
import os
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnableParallel, RunnablePassthrough, RunnableLambda
load_dotenv()
openai_api_key = os.getenv("OPENAI_API_KEY")
# İki farklı LLM örneği oluşturalım (biri varsayımsal olarak hata verebilir)
llm_primary = ChatOpenAI(api_key=openai_api_key, model="gpt-4o-2026-05-02", temperature=0.7)
llm_fallback = ChatOpenAI(api_key=openai_api_key, model="gpt-3.5-turbo-0125", temperature=0.9)
prompt = ChatPromptTemplate.from_template("Bana {topic} hakkında kısa bir özet ver.")
# Basit bir hata simülasyonu için RunnableLambda
def simulate_error(input_dict):
if input_dict["topic"] == "kuantum hesaplama":
raise ValueError("Kuantum hesaplama konusunda geçici hata!")
return input_dict
# Fallback mekanizması ile Chain oluşturma
chain_with_fallback = (
prompt
| RunnableLambda(simulate_error).with_fallback(llm_fallback) # Hata olursa fallback LLM'e geç
| StrOutputParser()
)
print("--- LCEL Fallback Örneği ---")
# Başarılı senaryo
print("AI 1 (başarılı):", chain_with_fallback.invoke({"topic": "yapay zeka"}))
# Hata senaryosu (fallback devreye girecek)
print("AI 2 (fallback):", chain_with_fallback.invoke({"topic": "kuantum hesaplama"}))
```
### 2. Custom Tools ve Agent'lar
LangChain'in yerleşik araçları yeterli olmadığında, kendi özel araçlarınızı (Custom Tools) oluşturabilir ve bunları Agent'larla kullanabilirsiniz. Bu, LLM'lerinize uygulamanızın iç işlevlerine veya özel API'lere erişim sağlar.
**Örnek: Özel Hesap Makinesi Aracı**
```python
# advanced_custom_tool.py
from dotenv import load_dotenv
import os
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_core.tools import Tool
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.messages import AIMessage, HumanMessage
load_dotenv()
openai_api_key = os.getenv("OPENAI_API_KEY")
llm = ChatOpenAI(api_key=openai_api_key, model="gpt-4o-2026-05-02", temperature=0)
# Özel hesap makinesi fonksiyonu
def calculate_expression(expression: str) -> str:
"""Bir matematiksel ifadeyi değerlendirir ve sonucunu döndürür."""
try:
return str(eval(expression))
except Exception as e:
return f"Hata: {e}"
# Özel aracı oluştur
calculator_tool = Tool(
name="Calculator",
func=calculate_expression,
description="Matematiksel ifadeleri hesaplamak için kullanışlıdır. Örn: '2+2', '15*3'"
)
tools = [calculator_tool]
prompt = ChatPromptTemplate.from_messages([
("system", "Sen bir yardımcı yapay zeka ajanısın. Matematiksel işlemleri Calculator aracını kullanarak çöz."),
MessagesPlaceholder(variable_name="chat_history", optional=True),
("human", "{input}"),
MessagesPlaceholder(variable_name="agent_scratchpad")
])
agent = create_openai_functions_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
print("--- Custom Tool Örneği ---")
response = agent_executor.invoke({"input": "15 ile 7'nin çarpımı nedir?"})
print(f"AI Cevabı: {response['output']}")
response_2 = agent_executor.invoke({"input": "Bana 2026'nın en iyi teknoloji trendlerini söyle."})
print(f"AI Cevabı: {response_2['output']}") # Bu soruyu tool kullanmadan cevaplamalı
```
### 3. LangServe ile Üretim Ortamına Dağıtım (Deployment)
LangServe, LangChain uygulamalarınızı bir REST API olarak kolayca dağıtmanızı sağlayan bir araçtır. Bu, uygulamalarınızı üretim ortamında kullanıma hazır hale getirmenin en etkili yollarından biridir. 2026 itibarıyla LangServe, LangChain ekosisteminin kritik bir parçasıdır.
**Örnek: Basit bir LangServe Uygulaması**
`app.py` dosyasını oluşturalım:
```python
# app.py
from dotenv import load_dotenv
import os
from fastapi import FastAPI
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langserve import add_routes
load_dotenv()
openai_api_key = os.getenv("OPENAI_API_KEY")
app = FastAPI(
title="LangChain Sunucu",
version="1.0",
description="Basit bir LangChain API'si"
)
llm = ChatOpenAI(api_key=openai_api_key, model="gpt-4o-2026-05-02")
prompt = ChatPromptTemplate.from_template("Bana {topic} hakkında kısa bir bilgi ver.")
chain = prompt | llm | StrOutputParser()
# Chain'i API olarak ekle
add_routes(app, chain, path="/simple_chain")
# Agent örneği (önceki örnekten)
from langchain.agents import AgentExecutor, create_openai_functions_agent
from langchain_community.tools import SerpAPIWrapper
from langchain_core.tools import Tool
from langchain_core.prompts import MessagesPlaceholder
serpapi_api_key = os.getenv("SERPAPI_API_KEY")
search = SerpAPIWrapper(serpapi_api_key=serpapi_api_key)
tools = [
Tool(
name="SerpAPI_Search",
func=search.run,
description="Güncel olaylar ve genel bilgiler için internette arama yapmak için kullanışlıdır."
)
]
agent_prompt = ChatPromptTemplate.from_messages([
("system", "Sen bir yardımcı yapay zeka ajanısın. Güncel bilgilere ihtiyacın olduğunda araçları kullan."),
MessagesPlaceholder(variable_name="chat_history", optional=True),
("human", "{input