H.Ozgan
a.k.a netologist

Bağlam Mühendisliği

13 Temmuz 2025 · netologist · 15 dakika, 3188 kelime

Giriş

Bağlam mühendisliği, 2025 yılında yapay zeka (AI) alanında önemli bir yer edinmiş, prompt mühendisliğinden evrilen yeni bir disiplindir. Prompt mühendisliği, büyük dil modelleri (LLM’ler) için belirli talimatlar oluşturmaya odaklanırken, bağlam mühendisliği, bir LLM’nin görevleri güvenilir ve etkili bir şekilde gerçekleştirmesini sağlamak için tüm bilgi ekosistemini tasarlamayı ve yönetmeyi içerir. Bu rapor, bağlam mühendisliğinin tanımı, önemi, teknikleri ve uygulamalarını, son sektör tartışmaları ve teknik kaynaklardan elde edilen bilgiler ışığında incelemektedir.

Bağlam Mühendisliği Nedir?

Bağlam mühendisliği, Andrej Karpathy tarafından “bağlam penceresini bir sonraki adım için doğru bilgilerle doldurmanın ince sanatı ve bilimi” olarak tanımlanmıştır. Tek bir prompt oluşturmanın ötesine geçerek, talimatlar, hafıza, harici veriler ve araçlar gibi bir LLM’nin işlediği tüm girdilerin stratejik bir şekilde düzenlenmesini kapsar. Shopify CEO’su Tobi Lütke, 19 Haziran 2025’te geniş yankı uyandıran bir paylaşımda, bunu “görevin LLM tarafından çözülebilir hale getirilmesi için tüm bağlamı sağlama sanatı” olarak nitelendirmiştir.

Prompt Mühendisliğinden Temel Farklar

Bağlam Mühendisliği Neden Önemli?

ChatGPT, Claude ve Gemini gibi LLM’ler daha yetkin hale geldikçe, başarısızlıkların çoğu modelin sınırlamalarından değil, yetersiz veya kötü yapılandırılmış bağlamdan kaynaklanmaktadır. Bağlam mühendisliği bunu şu yollarla ele alır:

Bağlam Mühendisliğinin Temel Bileşenleri

Bağlam mühendisliği, LLM’nin sınırlı “çalışma belleği” olan bağlam penceresini optimize etmek için birden fazla bilgi türünü yönetmeyi içerir. Ana bileşenler şunlardır:

  1. Talimatlar/Sistem Promptları: LLM’nin davranışını tanımlayan açık, yapılandırılmış yönergeler, genellikle kurallar veya örnekler içerir.
  2. Konuşma Geçmişi ve Hafıza: Geçmiş etkileşimleri takip ederek tutarlılığı sağlar; kısa vadeli (oturum bazlı) veya uzun vadeli (oturumlar arası) hafıza modülleri kullanılır.
  3. Alınan Bilgiler (RAG): Belgeler, veritabanları veya API’lerden alınan harici veriler, Alım Artırılmış Üretim (RAG) yoluyla güncel bilgi sağlamak için kullanılır.
  4. Araç Çıktıları: Arama API’leri veya kod yürütme gibi harici araçlardan elde edilen sonuçlar, LLM’nin yeteneklerini artırmak için bağlama entegre edilir.
  5. Yapılandırılmış Çıktılar: LLM’nin yanıt formatının (örneğin, JSON) tanımlanması, tutarlılık ve kullanılabilirlik sağlar.

Bağlam Mühendisliği Teknikleri

Bağlam mühendisliği, LLM’nin bağlam penceresinin sınırlı kapasitesini (örneğin, 8k, 32k veya 128k token) yönetmek ve performansı optimize etmek için çeşitli stratejiler kullanır. Temel teknikler şunlardır:

1. Alım Artırılmış Üretim (RAG)

RAG, statik LLM bilgisini, vektör veritabanları (örneğin, Pinecone, Weaviate) veya bilgi tabanlarından dinamik alımla birleştirir. Belgeler parçalara ayrılır, gömülür ve sorguya semantik benzerlik temelinde alınır, ardından prompt ile birleştirilir. Gelişmiş “ajan RAG”, planlama, araç kullanımı ve yansıtma ile çok adımlı döngüleri içerir.

2. Hafıza Yönetimi

3. Bağlam Seçimi ve Budama

4. Araç Yönetimi

Ajanlar genellikle arama API’leri veya kod yürütme ortamları gibi araçlar kullanır, ancak çok fazla araç kafa karışıklığına yol açabilir. Araç açıklamalarına RAG uygulamak, seçim doğruluğunu üç katına çıkarabilir. Kum havuzları, token ağırlıklı çıktıları izole ederek yalnızca ilgili sonuçları LLM’ye geri aktarır.

5. Çok Ajanlı Mimariler

Karmaşık görevlerde, çok ajanlı sistemler bağlamı alt görevlere böler, her biri uzmanlaşmış alt görevleri üstlenir. Ancak zayıf bağlam paylaşımı, tutarsız sonuçlara yol açabilir; örneğin, Flappy Bird klonunda alt ajanların uyumsuz bileşenler oluşturması gibi. Etkili bağlam mühendisliği, ajanlar arasında paylaşılan bağlamı sağlar.

6. Token Optimizasyonu

Sabit bağlam pencereleriyle, mühendisler bilgi yoğunluğuna öncelik vermelidir. Teknikler şunlardır:

Bağlam Mühendisliğinin Uygulamaları

Bağlam mühendisliği, güvenilir, ölçeklenebilir ve kişiselleştirilmiş sistemler sağlayarak sektörlerde yapay zeka uygulamalarını dönüştürmektedir. Örnekler:

Zorluklar ve Dikkat Edilmesi Gerekenler

Bağlam Mühendisliğinin Geleceği

Bağlam mühendisliği, Tobi Lütke ve Andrej Karpathy gibi sektör liderlerinin vurguladığı üzere, modern yapay zeka sistem tasarımının temeli olmaya hazırlanıyor. Yapay zeka ajanları geliştikçe, Anthropic’in Model Bağlam Protokolü, LangChain ve LlamaIndex gibi araçlar bağlam yönetimini standartlaştırıyor. Disiplin, ad-hoc prompt ayarlamasından sistematik orkestrasyona geçiş yaparak, yapay zekanın karmaşık, gerçek dünya görevlerini benzersiz bir güvenilirlikle ele almasını sağlıyor.

Örnek Çözüm: E-ticaret Platformunda Kişiselleştirilmiş Ürün Öneri Sistemi

Senaryo

Bir e-ticaret platformu, kullanıcılarına alışveriş alışkanlıklarına, geçmiş satın alımlarına ve gerçek zamanlı davranışlarına dayalı olarak kişiselleştirilmiş ürün önerileri sunmak istiyor. Mevcut sistem, statik kurallara dayalı öneriler üretiyor ve kullanıcıların dinamik ihtiyaçlarına yeterince yanıt veremiyor. Bağlam mühendisliği kullanarak, bir LLM tabanlı asistanın (örneğin, Grok 3) daha doğru, bağlama duyarlı öneriler sunmasını sağlayacağız.

Amaç

Çözüm Tasarımı

1. Sistem Mimarisi

Bağlam mühendisliği odaklı sistem şu bileşenlerden oluşacak:

2. Bağlam Mühendisliği Uygulaması

a) Sistem Promptu

LLM’ye net bir rol ve yönergeler verilir:

Sen bir e-ticaret asistanısın. Görevin, kullanıcıya geçmiş satın alımları, tarama davranışları ve ürün kataloğuna dayalı olarak kişiselleştirilmiş ürün önerileri sunmaktır. Yanıtlarını kısa, kullanıcı dostu ve JSON formatında sun. Öneriler, kullanıcının ilgi alanlarına uygun olmalı ve stokta olan ürünleri içermeli. Gizliliğe saygı göster; yalnızca sağlanan verileri kullan.

b) Hafıza Yönetimi

c) Retrieval-Augmented Generation (RAG)

d) Araç Entegrasyonu

e) Token Optimizasyonu

f) Yapılandırılmış Çıktı

LLM, önerileri JSON formatında üretir:

{
  "recommendations": [
    {
      "product_id": "prod1",
      "name": "Nike Air Max Kırmızı",
      "price": 1200,
      "reason": "Kırmızı spor ayakkabı aramanıza ve casual giyim tercihinize uygun."
    },
    {
      "product_id": "prod2",
      "name": "Adidas Ultraboost Kırmızı",
      "price": 1500,
      "reason": "Yüksek performanslı sneaker, son aramanızla uyumlu."
    }
  ]
}

3. İş Akışı

  1. Kullanıcı Etkileşimi: Kullanıcı “kırmızı spor ayakkabı” arar ve sepetine bir tişört ekler.
  2. Bağlam Toplama:
    • Kısa vadeli hafıza, tarama verilerini (arama, tıklamalar, sepet) kaydeder.
    • Uzun vadeli hafıza, kullanıcı profilinden geçmiş satın alımları ve tercihleri çeker.
    • RAG, ürün kataloğundan ilgili ürünleri alır.
    • Araçlar, öneri motoru ve arama API’sinden ek veriler sağlar.
  3. Bağlam Optimizasyonu: Bağlam yöneticisi, verileri özetler ve token sınırlarına uygun hale getirir.
  4. LLM İşleme: Grok 3, bağlamı işler ve JSON formatında öneriler üretir.
  5. Yanıt Sunumu: Öneriler, kullanıcıya web arayüzünde veya mobil uygulamada gösterilir.
  6. Geri Bildirim Döngüsü: Kullanıcı, önerilerden birini seçerse, bu veri uzun vadeli hafızaya eklenir ve gelecekteki öneriler için kullanılır.

4. Avantajlar

5. Zorluklar ve Çözümler

6. Kullanılan Teknolojiler

OpenAI ile Örnek Uygulama

OpenAI’nin API’sini (örneğin, gpt-4 veya benzer bir model) kullanarak e-ticaret platformu için kişiselleştirilmiş ürün öneri sistemini uygulayan bir Python kodu örneği sunuyorum. Bu kod, önceki bağlam mühendisliği prensiplerini (RAG, hafıza yönetimi, token optimizasyonu, araç entegrasyonu) koruyor ve OpenAI’nin openai kütüphanesi ile entegre oluyor. Grok 3 yerine OpenAI’nin modelini kullanıyoruz, ancak sistem mimarisi ve bağlam mühendisliği yaklaşımı aynı kalıyor.

Ön Koşullar

Kod

import json
import requests
from typing import Dict, List
from pinecone import Pinecone, ServerlessSpec
from openai import OpenAI

# OpenAI API istemcisi
openai_client = OpenAI(api_key="your-openai-api-key")  # OpenAI API anahtarınızı buraya ekleyin

# OpenAI API çağrısı
def call_openai_api(context: Dict) -> Dict:
    """
    OpenAI API'sini çağırarak öneriler üretir.
    :param context: Bağlam mühendisliği ile oluşturulan bağlam
    :return: JSON formatında öneriler
    """
    context_str = json.dumps(context, ensure_ascii=False)
    response = openai_client.chat.completions.create(
        model="gpt-4",  # veya başka bir model, örneğin "gpt-4-turbo"
        messages=[
            {"role": "system", "content": context["system_prompt"]},
            {"role": "user", "content": f"Bağlam: {context_str}\nLütfen JSON formatında ürün önerileri üret."}
        ],
        response_format={"type": "json_object"},  # JSON çıktısı için
        max_tokens=500,  # Yanıt için token sınırı
        temperature=0.7  # Yaratıcılık seviyesi
    )
    
    # Yanıtı JSON olarak döndür
    return json.loads(response.choices[0].message.content)

# Bağlam Mühendisliği Sınıfı
class ContextEngineer:
    def __init__(self, pinecone_api_key: str, recommendation_api_url: str):
        """
        Bağlam mühendisliği yöneticisi.
        :param pinecone_api_key: Pinecone vektör veritabanı için API anahtarı
        :param recommendation_api_url: Mevcut öneri motoru API'si
        """
        self.pc = Pinecone(api_key=pinecone_api_key)
        self.index_name = "product-catalog"
        self.recommendation_api_url = recommendation_api_url
        self.system_prompt = """
        Sen bir e-ticaret asistanısın. Görevin, kullanıcıya geçmiş satın alımları, tarama davranışları ve ürün kataloğuna dayalı olarak kişiselleştirilmiş ürün önerileri sunmaktır. Yanıtlarını kısa, kullanıcı dostu ve JSON formatında sun. Öneriler, kullanıcının ilgi alanlarına uygun olmalı ve stokta olan ürünleri içermeli. Gizliliğe saygı göster; yalnızca sağlanan verileri kullan.
        Örnek çıktı:
        {
          "recommendations": [
            {
              "product_id": "prod1",
              "name": "Ürün Adı",
              "price": 100,
              "reason": "Neden bu ürün önerildi."
            }
          ]
        }
        """

    def initialize_vector_db(self):
        """
        Pinecone vektör veritabanını başlatır ve ürün kataloğunu yükler.
        """
        # Örnek ürün verileri
        products = [
            {"id": "prod1", "name": "Nike Air Max Kırmızı", "category": "sneaker", "price": 1200, "stock": True},
            {"id": "prod2", "name": "Adidas Ultraboost Kırmızı", "category": "sneaker", "price": 1500, "stock": True},
            {"id": "prod3", "name": "Puma Siyah Tişört", "category": "tişört", "price": 300, "stock": True}
        ]
        
        # Pinecone indeksini oluştur
        if self.index_name not in self.pc.list_indexes().names():
            self.pc.create_index(
                name=self.index_name,
                dimension=128,  # Örnek embedding boyutu
                metric="cosine",
                spec=ServerlessSpec(cloud="aws", region="us-west-2")
            )
        
        # Ürünleri vektör veritabanına ekle (basitleştirilmiş embedding)
        index = self.pc.Index(self.index_name)
        for product in products:
            # Gerçek uygulamada, ürün açıklamaları için bir embedding modeli (örn. BERT) kullanılır
            vector = [0.1] * 128  # Simüle edilmiş embedding
            index.upsert([(product["id"], vector, product)])

    def fetch_user_data(self, user_id: str, session_data: Dict) -> Dict:
        """
        Kullanıcı verilerini toplar (kısa ve uzun vadeli hafıza).
        """
        # Uzun vadeli hafıza (örnek veri)
        long_term_memory = {
            "user_id": user_id,
            "past_purchases": ["mavi kot pantolon", "siyah sırt çantası"],
            "preferences": ["casual giyim", "sneaker"]
        }
        
        # Kısa vadeli hafıza (oturum verileri)
        short_term_memory = session_data
        
        return {
            "long_term": long_term_memory,
            "short_term": short_term_memory
        }

    def retrieve_products(self, query: str) -> List[Dict]:
        """
        RAG kullanarak ürün kataloğundan ilgili ürünleri alır.
        """
        index = self.pc.Index(self.index_name)
        # Simüle edilmiş vektör sorgusu (gerçekte, sorgu için embedding üretilir)
        query_vector = [0.1] * 128
        results = index.query(vector=query_vector, top_k=2, include_metadata=True)
        
        products = [
            result["metadata"] for result in results["matches"]
            if result["metadata"]["stock"]  # Yalnızca stokta olanlar
        ]
        return products

    def call_recommendation_api(self, user_data: Dict) -> Dict:
        """
        Mevcut öneri motoru API'sini çağırır.
        """
        try:
            response = requests.post(self.recommendation_api_url, json=user_data)
            return response.json()
        except Exception as e:
            print(f"API hatası: {e}")
            return {"recommendations": []}

    def build_context(self, user_id: str, session_data: Dict, query: str) -> Dict:
        """
        Bağlamı oluşturur ve optimize eder.
        """
        # Kullanıcı verilerini topla
        user_data = self.fetch_user_data(user_id, session_data)
        
        # RAG ile ürünleri al
        retrieved_products = self.retrieve_products(query)
        
        # Öneri motoru API'sinden veri al
        toolobserve: System: tool_output = self.call_recommendation_api(user_data)
        
        # Bağlamı oluştur
        context = {
            "system_prompt": self.system_prompt,
            "user_data": {
                "current_search": query,
                "past_purchases": user_data["long_term"]["past_purchases"],
                "preferences": user_data["long_term"]["preferences"]
            },
            "retrieved_products": retrieved_products,
            "tool_output": tool_output
        }
        
        # Token optimizasyonu: Bağlam boyutu 32k token sınırını aşarsa budama
        context_str = json.dumps(context, ensure_ascii=False)
        if len(context_str) > 32000:  # Örnek token sınırı
            context["retrieved_products"] = context["retrieved_products"][:2]  # İlk 2 ürünü al
            context["user_data"]["past_purchases"] = context["user_data"]["past_purchases"][:1]  # Son 1 satın alımı al
        
        return context

    def generate_recommendations(self, user_id: str, session_data: Dict, query: str) -> Dict:
        """
        Önerileri üretir.
        """
        context = self.build_context(user_id, session_data, query)
        response = call_openai_api(context)
        return response

# Kullanım Örneği
if __name__ == "__main__":
    # Örnek yapılandırma
    pinecone_api_key = "your-pinecone-api-key"  # Gerçek anahtarınızı kullanın
    recommendation_api_url = "http://example-recommendintregration-api.com"
    
    # Bağlam mühendisini başlat
    engineer = ContextEngineer(pinecone_api_key, recommendation_api_url)
    engineer.initialize_vector_db()
    
    # Örnek kullanıcı verileri
    user_id = "user789"
    session_data = {
        "session_id": "12345",
        "current_search": "kırmızı spor ayakkabı",
        "cart": ["beyaz tişört"],
        "clicks": ["nike koşu ayakkabısı", "adidas tişört"]
    }
    
    # Önerileri üret
    recommendations = engineer.generate_recommendations(user_id, session_data, "kırmızı spor ayakkabı")
    
    # Sonuçları yazdır
    print(json.dumps(recommendations, indent=2, ensure_ascii=False))

Kod Açıklaması

  1. OpenAI Entegrasyonu:

    • call_openai_api fonksiyonu, OpenAI’nin gpt-4 modelini çağırır ve bağlamı JSON formatında işleyerek yapılandırılmış öneriler üretir.
    • response_format={"type": "json_object"} parametresi, çıktının JSON formatında olmasını sağlar.
    • max_tokens ve temperature parametreleri, yanıt uzunluğunu ve yaratıcılık seviyesini kontrol eder.

  2. Bağlam Mühendisliği Teknikleri:

    • RAG: Pinecone vektör veritabanı, ürün kataloğundan ilgili ürünleri almak için kullanılır.
    • Hafıza Yönetimi: Kullanıcı verileri kısa vadeli (oturum verileri) ve uzun vadeli (kullanıcı profili) hafıza olarak toplanır.
    • Token Optimizasyonu: Bağlam boyutu 32k token sınırını aşarsa, ürünler ve geçmiş satın alımlar sınırlandırılır.
    • Araç Entegrasyonu: Öneri motoru API’si ve Pinecone’dan alınan veriler bağlama entegre edilir.
    • Yapılandırılmış Çıktı: OpenAI, JSON formatında tutarlı öneriler üretir.

  3. Örnek Çıktı:

{
  "recommendations": [
    {
      "product_id": "prod1",
      "name": "Nike Air Max Kırmızı",
      "price": 1200,
      "reason": "Aramanıza uygun, casual giyim tarzınıza uyan popüler bir sneaker."
    },
    {
      "product_id": "prod2",
      "name": "Adidas Ultraboost Kırmızı",
      "price": 1500,
      "reason": "Yüksek performanslı kırmızı sneaker, son aramanızla uyumlu."
    }
  ]
}

Kurulum ve Çalıştırma

  1. Kütüphaneleri Yükleyin:
    pip install openai pinecone-client requests
  2. OpenAI API Anahtarı: OpenAI’ye kaydolun ve bir API anahtarı alın (your-openai-api-key yerine ekleyin).
  3. Pinecone API Anahtarı: Pinecone’a kaydolun ve bir API anahtarı alın.
  4. Öneri API’si: Şirket içi bir öneri motoru API’si URL’sini sağlayın veya simüle edilmiş bir API kullanın.
  5. Kodu Çalıştırın:
    python recommendation_system_openai.py

Sınırlamalar ve İyileştirmeler

Ek Notlar

Sonuç

Bağlam mühendisliği, prompt mühendisliğinin ötesine geçerek dinamik, bağlam farkında sistemler yaratmada bir paradigma değişimi temsil eder. Talimatları, hafızayı, alınan verileri ve araçları dikkatle düzenleyerek, bağlam mühendisleri LLM’lerin doğru, tutarlı ve ölçeklenebilir sonuçlar sunmasını sağlar. Organizasyonlar, ajan sistemlerini benimsedikçe ve yapay zekayı kritik iş akışlarına entegre ettikçe, bağlam mühendisliğini ustalaşmak, LLM’lerin tüm potansiyelini açığa çıkarmak için vazgeçilmez olacaktır.

Kaynaklar