Python Ortamına LangChain Kurulumu ve Temel Yapılandırma

Yazar:komut.io ekibi
0 Yorum

Yapay zeka uygulamaları geliştirme dünyasına adım atmak isteyenler için LangChain, son yılların en popüler framework’lerinden biri haline geldi. OpenAI, Anthropic, Hugging Face gibi farklı LLM sağlayıcılarını tek bir çatı altında kullanmanı sağlayan bu kütüphane, production ortamına taşıyabileceğin gerçek AI uygulamaları yazmak için güçlü bir temel sunuyor. Bu yazıda sıfırdan başlayarak Python ortamını nasıl hazırlayacağını, LangChain’i nasıl kuracağını ve temel yapılandırmaları nasıl yapacağını adım adım göstereceğim.

Neden LangChain?

Bir sysadmin olarak “bana ne faydası var?” diye sorabilirsin. Haklısın. LangChain’in benim için anlamlı hale geldiği an, log dosyalarını analiz eden, hata mesajlarını yorumlayan ve ekibe özet rapor çıkaran bir araç yazmak istediğimde oldu. Normalde bu iş için OpenAI API’sini doğrudan kullanırdım, ama prompt yönetimi, hafıza, zincirleme işlemler derken kod karmaşıklaşıyordu. LangChain bu sorunların üstesinden gelecek soyutlama katmanını sunuyor.

Kısaca ne işe yarıyor?

  • LLM entegrasyonu: GPT-4, Claude, Gemini, Llama gibi modelleri aynı interface ile kullanabiliyorsun
  • Prompt yönetimi: Template sistemi ile tekrar kullanılabilir, versiyonlanabilir promptlar
  • Bellek yönetimi: Konuşma geçmişini yönetmek için hazır araçlar
  • Araç ve ajan desteği: LLM’in dış sistemlere (API, veritabanı, dosya sistemi) erişmesini sağlayan ajan mimarisi
  • RAG desteği: Kendi dökümanlarını vektör veritabanına yükleyip sorgulatabilme

Ortam Hazırlığı

Python Sürümü Kontrolü

LangChain için Python 3.9 veya üzeri gerekiyor. Önce mevcut Python sürümünü kontrol et:

python3 --version
# veya
python --version

# Pip sürümünü de güncel tut
pip install --upgrade pip

Eğer sisteminizde birden fazla Python sürümü varsa ve doğru sürümü kullandığından emin olmak istiyorsan:

# Hangi python binary'sini kullandığını görmek için
which python3
ls -la /usr/bin/python*

# Ubuntu/Debian'da alternatif Python sürümü yönetimi
sudo apt list --installed | grep python3

Virtual Environment Oluşturma

Bu adımı asla atlama. LangChain ve bağımlılıkları oldukça kapsamlı, sistem Python’una doğrudan kurmak ileride ciddi versiyon çakışmalarına yol açar. Her proje için ayrı bir sanal ortam kullan.

# Proje dizini oluştur
mkdir ~/langchain-projesi
cd ~/langchain-projesi

# Virtual environment oluştur
python3 -m venv venv

# Aktive et (Linux/macOS)
source venv/bin/activate

# Windows için
# venvScriptsactivate

# Aktive olduğunu prompt'taki (venv) ifadesinden anlayabilirsin
# (venv) kullanici@sunucu:~/langchain-projesi$

Alternatif olarak conda kullanıyorsan:

conda create -n langchain-env python=3.11
conda activate langchain-env

LangChain Kurulumu

Temel Paket Kurulumu

LangChain modüler bir yapıya sahip. 2024 itibarıyla ana paket langchain ile birlikte langchain-core ve kullanmak istediğin LLM sağlayıcısına özel paketleri ayrı ayrı kurman gerekiyor. Bu modüler yapı başlangıçta karmaşık gelebilir ama gereksiz bağımlılıkları projene dahil etmemeni sağlıyor.

# Temel LangChain paketleri
pip install langchain
pip install langchain-core
pip install langchain-community

# OpenAI entegrasyonu için
pip install langchain-openai

# Anthropic Claude entegrasyonu için (opsiyonel)
pip install langchain-anthropic

# Hugging Face entegrasyonu için (opsiyonel)
pip install langchain-huggingface

# Kurulumu doğrula
pip show langchain
pip show langchain-core

Ek Bağımlılıklar

Gerçek dünya projelerinde ihtiyaç duyacağın bazı ek paketler:

# Ortam değişkeni yönetimi için
pip install python-dotenv

# Vektör veritabanı (ChromaDB - yerel kullanım için)
pip install chromadb

# Döküman işleme
pip install pypdf
pip install docx2txt

# HTTP istekleri ve araç entegrasyonları
pip install requests
pip install beautifulsoup4

# Tüm kurulu paketleri requirements.txt'e kaydet
pip freeze > requirements.txt

Kurulumu Doğrulama

python3 -c "
import langchain
import langchain_core
import langchain_community
print(f'LangChain: {langchain.__version__}')
print(f'LangChain Core: {langchain_core.__version__}')
print('Kurulum basarili!')
"

API Anahtarı Yapılandırması

.env Dosyası ile Güvenli Yönetim

API anahtarlarını doğrudan koda yazmak ciddi bir güvenlik açığı. Özellikle kodunu Git’e pushluyorsan bu hatayı yapma. .env dosyası kullan ve bu dosyayı .gitignore‘a ekle.

# .env dosyası oluştur
cat > .env << 'EOF'
# OpenAI API Anahtarı
OPENAI_API_KEY=sk-proj-xxxxxxxxxxxxxxxxxxxxxxxxxx

# Anthropic API Anahtarı (varsa)
ANTHROPIC_API_KEY=sk-ant-xxxxxxxxxxxxxxxxxxxxxxxxxx

# LangSmith için (opsiyonel - debugging aracı)
LANGCHAIN_TRACING_V2=true
LANGCHAIN_API_KEY=ls__xxxxxxxxxxxxxxxxxxxxxxxxxx
LANGCHAIN_PROJECT=benim-projem

# Hugging Face Token (opsiyonel)
HUGGINGFACEHUB_API_TOKEN=hf_xxxxxxxxxxxxxxxxxxxxxxxxxx
EOF

# .gitignore dosyasına ekle
echo ".env" >> .gitignore
echo "venv/" >> .gitignore
echo "__pycache__/" >> .gitignore
echo "*.pyc" >> .gitignore

.env Dosyasını Python’da Kullanma

# config.py
from dotenv import load_dotenv
import os

# .env dosyasını yükle
load_dotenv()

# API anahtarlarını ortam değişkeninden al
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")

# Anahtar varlığını kontrol et
def check_api_keys():
    required_keys = ["OPENAI_API_KEY"]
    missing_keys = []
    
    for key in required_keys:
        if not os.getenv(key):
            missing_keys.append(key)
    
    if missing_keys:
        raise ValueError(f"Eksik API anahtarlari: {', '.join(missing_keys)}")
    
    print("Tüm gerekli API anahtarlari mevcut.")

if __name__ == "__main__":
    check_api_keys()

İlk LangChain Uygulaması

Basit Bir LLM Çağrısı

# ilk_uygulama.py
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage

load_dotenv()

# Model oluştur
model = ChatOpenAI(
    model="gpt-4o-mini",  # Daha ucuz ve hızlı model
    temperature=0.7,       # 0: deterministik, 1: yaratıcı
    max_tokens=500
)

# Basit bir soru sor
messages = [
    SystemMessage(content="Sen yardımcı bir Linux sistem yöneticisisin. Kısa ve net cevaplar ver."),
    HumanMessage(content="nginx log dosyası nerede bulunur?")
]

response = model.invoke(messages)
print(response.content)

Bu kodu çalıştırdığında modelin cevabını göreceksin. Şimdi biraz daha ileri gidelim.

Prompt Template Kullanımı

Prompt template’ler, tekrar kullanılabilir ve parametrik promptlar oluşturmana olanak tanır. Log analizi senaryosu için bunu kullanalım:

# prompt_template_ornek.py
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

load_dotenv()

# Prompt template tanımla
prompt = ChatPromptTemplate.from_messages([
    ("system", """Sen bir Linux sistem yöneticisi asistanısın. 
    Sana verilen log çıktısını analiz et ve şunları belirt:
    1. Tespit edilen hatalar
    2. Olası nedeni
    3. Önerilen çözüm adımları
    Cevabı Türkçe ver."""),
    ("human", "Analiz edilecek log:n{log_content}")
])

# Model ve output parser
model = ChatOpenAI(model="gpt-4o-mini", temperature=0)
output_parser = StrOutputParser()

# Chain oluştur (LCEL - LangChain Expression Language)
chain = prompt | model | output_parser

# Örnek log verisi
ornek_log = """
2024-01-15 14:23:41 ERROR nginx: connect() failed (111: Connection refused) 
while connecting to upstream, client: 192.168.1.100, 
server: example.com, upstream: "http://127.0.0.1:8080"
2024-01-15 14:23:42 ERROR nginx: no live upstreams while connecting to upstream
2024-01-15 14:23:45 WARN nginx: upstream response timeout (11: Resource temporarily unavailable)
"""

# Chain'i çalıştır
sonuc = chain.invoke({"log_content": ornek_log})
print(sonuc)

Konuşma Hafızası ile Chatbot

Gerçek bir chatbot senaryosunda konuşma geçmişini tutman gerekir. LangChain bunu kolaylaştırıyor:

# chatbot_hafiza.py
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.messages import HumanMessage, AIMessage
from langchain_core.output_parsers import StrOutputParser

load_dotenv()

model = ChatOpenAI(model="gpt-4o-mini", temperature=0.7)

prompt = ChatPromptTemplate.from_messages([
    ("system", "Sen yardımcı bir sistem yöneticisi asistanısın. Kısa ve öz cevaplar ver."),
    MessagesPlaceholder(variable_name="chat_history"),
    ("human", "{input}")
])

chain = prompt | model | StrOutputParser()

# Konuşma geçmişini tut
chat_history = []

def chat(kullanici_mesaji: str) -> str:
    response = chain.invoke({
        "input": kullanici_mesaji,
        "chat_history": chat_history
    })
    
    # Geçmişe ekle
    chat_history.append(HumanMessage(content=kullanici_mesaji))
    chat_history.append(AIMessage(content=response))
    
    return response

# Örnek kullanım
print("Bot:", chat("Merhaba, nginx'i nasıl yeniden başlatırım?"))
print("Bot:", chat("Peki bu işlem kaç saniye sürer?"))
print("Bot:", chat("Önceki söylediğini tekrar açıklar mısın?"))

Yapılandırma ve Optimizasyon

Model Parametrelerini Anlamak

Sıkça kullanılan parametreler:

  • temperature: Çıktının yaratıcılık seviyesi. 0 deterministic, 1 yaratıcı. Log analizi gibi teknik görevler için 0 kullan.
  • max_tokens: Maksimum çıktı uzunluğu. API maliyetini kontrol etmek için kritik.
  • model: Kullanılacak model adı. gpt-4o-mini ucuz, gpt-4o daha yetenekli.
  • timeout: API yanıt bekleme süresi (saniye). Production’da mutlaka ayarla.
  • max_retries: Hata durumunda kaç kez tekrar denensin.
# Yapılandırılmış model örneği
from langchain_openai import ChatOpenAI

model = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0,
    max_tokens=1000,
    timeout=30,
    max_retries=3
)

Streaming ile Gerçek Zamanlı Çıktı

Uzun cevaplar için streaming kullanmak kullanıcı deneyimini iyileştirir:

# streaming_ornek.py
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

load_dotenv()

model = ChatOpenAI(model="gpt-4o-mini", temperature=0)

print("Cevap: ", end="", flush=True)

# Streaming ile chunk chunk yazdır
for chunk in model.stream([
    HumanMessage(content="Linux'ta disk kullanımını izlemek için 5 farklı yöntem anlat.")
]):
    print(chunk.content, end="", flush=True)

print()  # Yeni satır

Hata Yönetimi

Production ortamında hata yönetimi şart:

# hata_yonetimi.py
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage
from openai import RateLimitError, APIConnectionError, APITimeoutError
import time
import logging

load_dotenv()
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def llm_sor(soru: str, max_deneme: int = 3) -> str:
    model = ChatOpenAI(model="gpt-4o-mini", temperature=0, timeout=30)
    
    for deneme in range(max_deneme):
        try:
            response = model.invoke([HumanMessage(content=soru)])
            return response.content
            
        except RateLimitError:
            bekleme = 2 ** deneme  # Exponential backoff
            logger.warning(f"Rate limit asildi. {bekleme} saniye bekleniyor...")
            time.sleep(bekleme)
            
        except APIConnectionError as e:
            logger.error(f"Baglanti hatasi: {e}")
            if deneme == max_deneme - 1:
                raise
                
        except APITimeoutError:
            logger.error(f"Zaman asimi. Deneme {deneme + 1}/{max_deneme}")
            if deneme == max_deneme - 1:
                raise
    
    raise Exception("Maksimum deneme sayisina ulasildi.")

# Kullanım
try:
    cevap = llm_sor("Docker container'larında log yönetimi nasıl yapılır?")
    print(cevap)
except Exception as e:
    print(f"Hata: {e}")

Pratik Bir Senaryo: Sistem Raporu Analisti

Şimdi tüm öğrendiklerimizi bir araya getirerek gerçekten işe yarar bir araç yazalım. Bu araç, sistem komutlarının çıktısını alıp yorumlayan bir asistan görevi görüyor:

# sistem_analisti.py
import subprocess
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

load_dotenv()

def sistem_bilgisi_topla() -> dict:
    """Temel sistem bilgilerini toplar."""
    komutlar = {
        "disk_kullanimi": "df -h",
        "bellek_kullanimi": "free -h",
        "cpu_yukü": "uptime",
        "aktif_servisler": "systemctl list-units --type=service --state=running --no-pager | head -20",
    }
    
    bilgiler = {}
    for isim, komut in komutlar.items():
        try:
            sonuc = subprocess.run(
                komut.split(),
                capture_output=True,
                text=True,
                timeout=10
            )
            bilgiler[isim] = sonuc.stdout
        except Exception as e:
            bilgiler[isim] = f"Hata: {e}"
    
    return bilgiler

def sistem_raporu_olustur():
    """Sistem bilgilerini analiz edip rapor oluşturur."""
    
    print("Sistem bilgileri toplanıyor...")
    bilgiler = sistem_bilgisi_topla()
    
    sistem_durumu = f"""
    DISK KULLANIMI:
    {bilgiler.get('disk_kullanimi', 'Bilgi alinamadi')}
    
    BELLEK KULLANIMI:
    {bilgiler.get('bellek_kullanimi', 'Bilgi alinamadi')}
    
    CPU YÜKÜ:
    {bilgiler.get('cpu_yukü', 'Bilgi alinamadi')}
    
    AKTIF SERVİSLER:
    {bilgiler.get('aktif_servisler', 'Bilgi alinamadi')}
    """
    
    prompt = ChatPromptTemplate.from_messages([
        ("system", """Sen deneyimli bir Linux sistem yöneticisisin. 
        Sana verilen sistem durumu bilgilerini analiz et ve şunları içeren kısa bir rapor hazırla:
        - Genel sistem sağlığı durumu
        - Dikkat edilmesi gereken noktalar
        - Acil aksiyon gerektiren durumlar (varsa)
        Raporu Türkçe ve madde madde yaz."""),
        ("human", "Sistem durumu:n{sistem_durumu}")
    ])
    
    model = ChatOpenAI(model="gpt-4o-mini", temperature=0)
    chain = prompt | model | StrOutputParser()
    
    print("Rapor hazırlanıyor...n")
    rapor = chain.invoke({"sistem_durumu": sistem_durumu})
    print("=" * 50)
    print("SİSTEM DURUM RAPORU")
    print("=" * 50)
    print(rapor)

if __name__ == "__main__":
    sistem_raporu_olustur()

Proje Yapısını Düzenleme

Büyüyen projeler için temiz bir yapı önemli:

langchain-projesi/
├── venv/
├── .env
├── .gitignore
├── requirements.txt
├── config.py
├── src/
│   ├── __init__.py
│   ├── models.py       # Model tanımlamaları
│   ├── prompts.py      # Prompt template'ler
│   └── chains.py       # Chain tanımlamaları
├── scripts/
│   ├── sistem_analisti.py
│   └── log_analizi.py
└── tests/
    └── test_chains.py

Bu yapıyı oluşturmak için:

mkdir -p src scripts tests
touch src/__init__.py src/models.py src/prompts.py src/chains.py
touch scripts/sistem_analisti.py scripts/log_analizi.py
touch tests/test_chains.py

LangSmith ile Debugging

LangSmith, LangChain’in resmi debugging ve monitoring aracı. Ücretsiz tier ile başlayabilirsin. .env dosyana şunları ekle:

# LangSmith yapılandırması
LANGCHAIN_TRACING_V2=true
LANGCHAIN_ENDPOINT=https://api.smith.langchain.com
LANGCHAIN_API_KEY=ls__xxxxxxxxxxxxxxxx
LANGCHAIN_PROJECT=sysadmin-asistan

Bu ayarları yaptıktan sonra tüm LangChain çağrıların LangSmith dashboard’unda görünür hale gelir. Hangi promptların ne kadar token tükettiğini, yanıt sürelerini ve hataları izleyebilirsin.

Sonuç

Bu yazıda Python ortamını sıfırdan hazırlamaktan LangChain kurulumuna, API anahtarı yönetiminden ilk çalışan uygulamaya kadar kapsamlı bir yolculuk yaptık. Birkaç kritik noktayı tekrar vurgulamak istiyorum:

Her zaman virtual environment kullan. Bu kuralı çiğnemek ileride saatler kaybettiren bağımlılık sorunlarına yol açar. API anahtarlarını .env dosyasında tut ve bu dosyayı asla Git’e commit etme. Production uygulamalarında hata yönetimi ve timeout ayarları zorunlu, bunlarsız kodun güvenilmez davranır.

LangChain’in öğrenme eğrisi başlangıçta dik görünebilir, özellikle LCEL (LangChain Expression Language) ve yeni modüler yapıya alışmak zaman alıyor. Ancak bir kez kavradığında, karmaşık AI iş akışlarını son derece hızlı şekilde hayata geçirebiliyorsun. Sysadmin perspektifinden bakıldığında log analizi, otomatik raporlama, akıllı monitoring alertleri ve dokümantasyon üretimi gibi konularda LangChain gerçekten işe yarıyor.

Bir sonraki yazıda RAG (Retrieval Augmented Generation) konusunu ele alacağım. Kendi sistem dökümanlarını, runbook’larını ve hata çözüm rehberlerini bir vektör veritabanına yükleyip yapay zekanın bunları kullanarak soruları yanıtlamasını sağlayacağız. Bu, gerçekten işe yarar bir bilgi tabanı asistanı oluşturmanın temelini oluşturuyor.

Bir yanıt yazın

E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir