DeepSeek V3.2: Demo Projesiyle Bir Rehber

DeepSeek kısa süre önce v3.2-Exp adlı, API maliyetlerini yarıdan fazla düşüren deneysel bir modeli yayımladı. Büyük dil modelleriyle çalışıyorsanız, uzun bağlam işlemenin hızla pahalılaştığını bilirsiniz. Bu yeni sürüm, DeepSeek Sparse Attention adlı bir teknikle bu sorunu ele alıyor.

Bu eğitimde, v3.2 sürümünü önceki DeepSeek sürümlerinden farklı kılan şeyleri, seyrek dikkatin kaputun altında nasıl çalıştığını ve modeli projelerinizde nasıl kullanabileceğinizi açıklayacağım. API çağrısı yapmanın temellerini ele alacak ve bu modelin en iyi nerede işe yaradığını gösteren bir demo proje oluşturacağız.

Sonunda, DeepSeek v3.2 dahil farklı LLM’ler arasında maliyetleri karşılaştıran bir Streamlit uygulaması oluşturmuş olacaksınız:

Ayrıca yeni DeepSeek-V3.2-Speciale varyantını ele alan demo projemize de göz atmanızı öneririm. 

DeepSeek V3.2 Nedir?

Önce DeepSeek hakkında biraz arka plan ve bu sürümde nelerin değiştiğiyle başlayalım.

DeepSeek model ailesi

DeepSeek, MIT lisansı altında büyük dil modelleri geliştiren, Çin merkezli bir açık kaynak yapay zeka şirketidir. Modelleri, akıl yürütme, kodlama ve genel amaçlı görevlerde GPT-5 ve Claude ile rekabet eder. Şirket geçen yıl boyunca DeepSeek-V3 ve DeepSeek-R1 dahil olmak üzere çeşitli sürümler yayımladı; kapalı kaynak alternatiflerden daha düşük maliyetle güçlü performanslarıyla dikkat çektiler.

v3.2’den önceki en güncel sürüm, 685 milyar parametreli v3.1-Terminus idi. Sağlam performans sunsa da uzun bağlamları işlemek hâlâ pahalıydı. Yeni deneysel sürüm burada devreye giriyor.

V3.2-Exp: Deneysel sürüm

DeepSeek v3.2-Exp’i 29 Eylül 2025’te (2025-09-29) yayımladı. "Exp" deneysel anlamına gelir; yani model hâlen test edilip iyileştiriliyor. Şimdilik üretim seviyesinde kararlılık beklemeyin; ancak en yeni özellikleri denemek istediğiniz araştırmalar ve projeler için kullanabilirsiniz.

Model, v3.1-Terminus üzerine inşa edilmiştir ve aynı 685B parametre mimarisini korur. Fark yaratan, bilgiyi dahili olarak işleme biçimidir. OpenAI ile uyumlu bir API formatı kullanır; dolayısıyla daha önce OpenAI SDK’sını kullandıysanız, DeepSeek ile nasıl çalışacağınızı zaten biliyorsunuz (bu yazıda ilk API çağrınızı nasıl yapacağınızı da açıklayacağım).

Başlıca yenilik: Maliyet ve verimlilik

Büyük değişim şu: DeepSeek, API fiyatlarını v3.1’e kıyasla %50’den fazla düşürdü. Ve performans aynı kaldı. Aynı yanıt kalitesini yarı maliyetle alıyorsunuz.

Bu fiyat düşüşü, DeepSeek Sparse Attention (DSA) adlı teknik bir iyileştirmeden kaynaklanıyor. Modelin girdinizdeki her bir token’a dikkat etmesi (hesaplama açısından pahalı) yerine, DSA önemli olana seçici olarak odaklanır. Bunun nasıl çalıştığını bir sonraki bölümde inceleyeceğiz.

Tüm teknik ayrıntılar için DeepSeek, mimari değişiklikleri ve karşılaştırma sonuçlarını açıklayan GitHub’da teknik bir rapor yayımladı.

DeepSeek Sparse Attention (DSA) Nedir?

Koda geçmeden önce, v3.2’yi daha ucuz ve hızlı kılan şeyden bahsedelim. Cevap, modelin girdinizi nasıl işlemesinde yatıyor.

Transformer’larda dikkat mekanizmaları: Kısa bir özet

Bir dil modeline metin gönderdiğinizde, girdiğinizi token’lara (kabaca kelimeler veya kelime parçaları) böler. Model daha sonra hangi token’ların birbirleriyle ilişkili olduğunu bulmalıdır. Bu sürece dikkat denir.

Geleneksel transformer’larda her token diğer tüm token’lara bakar. 1.000 token’ınız varsa her biri diğer 999’unu kontrol eder. Bu, 1 milyon karşılaştırma demektir. 10.000 token’da 100 milyon karşılaştırmaya ulaşırsınız. Matematik kuadratiktir: girdi uzunluğunuzu ikiye katladığınızda, hesaplama maliyetini dörde katlarsınız.

Uzun bağlam işlemenin pahalılaşmasının nedeni budur. Belgeleriniz uzadıkça API faturanız hızla büyür.

Seyrek dikkat ne anlama gelir?

Tüm token’ların diğer tüm token’lara bakması gerekmez. Şu anda bu cümleyi okurken, önceki her kelimeyi sürekli yeniden okumuyorsunuz. İlgili olana odaklanıyorsunuz.

Seyrek dikkat de aynısını yapar. Her token’ı her diğeriyle karşılaştırmak yerine, model hangi karşılaştırmaların önemli olduğunu seçer. Daha eski bazı yaklaşımlar şunları içerir:

• Blok-seyrek dikkat: Token’ları bloklara ayırın ve yalnızca yakın blokların birbirine dikkat etmesine izin verin
• Yerel pencere dikkati: Her token yalnızca sabit bir mesafe içindeki token’lara bakar

Bu yöntemler hesaplamayı azaltır, ancak katıdır. Metninizin ne dediğinden bağımsız olarak, hangi token’ların etkileşebileceğine en baştan karar verirler. Bazen bir belgenin başındaki bir kelimenin sonundaki bir şeyle bağlantı kurması gerekir. Sabit kalıplar bunu kaçırabilir.

DeepSeek Sparse Attention (DSA): İnce ayarlı bir yaklaşım

DSA farklı bir yol izler. Sabit kalıplar kullanmak yerine, içerik temelinde hangi token’ların gerçekten birbirine dikkat etmesi gerektiğini öğrenir. Model, ilgili bağlantıları anlık olarak seçer.

Yüksek seviyede nasıl çalıştığı şöyle. Eğitim sırasında DeepSeek, her dikkat katmanına bir seçim mekanizması ekledi. Bu mekanizma token’larınıza bakar ve hangi dikkat bağlantılarının hesaplanmaya değer olduğuna karar verir. Önemlileri tutar, geri kalanını atlar.

Seçim rastgele değildir. Model, eğitim sırasında farklı görevler için hangi tür bağlantıların önemli olduğunu öğrendi. Koda dair bir istem gönderdiğinizde, hukuki bir belge gönderdiğiniz zamana göre farklı kalıplara odaklanır.

Sonuç: DSA, çıktı kalitesine zarar vermeden dikkat işlemlerinin sayısını azaltır. Teknik raporda, DeepSeek v3.2’nin kıyaslamalarda v3.1-Terminus ile neredeyse aynı performansı gösterirken token başına daha az hesaplama yaptığını ortaya koyuyor. Yaklaşık yarı API maliyetine aynı model kalitesini elde edersiniz.

Geliştiriciler için neden önemli

DSA’nın pratikteki anlamı şudur:

• Daha düşük API maliyetleri: Aynı yanıt kalitesi için daha az ödersiniz
• Daha iyi uzun bağlam yönetimi: Model 128K token bağlam penceresini destekler ve seyrek dikkat olmayan modellere göre bu uzun girdileri daha ucuza işler
• Daha hızlı çıkarım: Daha az işlem daha hızlı yanıt süreleri demektir

Faydalar en çok şu kullanım senaryolarında ortaya çıkar:

• Aynı anda birden fazla belgenin analiz edilmesi
• Uzun konuşmalarda bağlamın korunması
• Büyük kod tabanlarının veya teknik belgelerin işlenmesi
• Araştırma makalelerinin veya hukuki sözleşmelerin özetlenmesi

Uygulamanız uzun girdilerle uğraşıyorsa, DSA gerçek bir fark yaratır. Sadece para tasarrufu yapmıyorsunuz. Geleneksel dikkatin zorlandığı görevlerde daha iyi performans elde ediyorsunuz.

İlk DeepSeek V3.2 Çağrınızı Yapma

Artık DSA’nın nasıl çalıştığını anladığınıza göre, modeli API’si üzerinden kullanalım.

Önkoşullar

Makinenizde Python 3.8 veya daha yenisi kurulu olmalı. API’ler üzerinden LLM’lerle yeni çalışmaya başladıysanız, temel konulara aşina olmak için DataCamp’in yapay zekayı öğrenme rehberine göz atabilirsiniz. Daha derine inmek isterseniz önceki sürümleri kapsayan daha ayrıntılı bir DeepSeek API eğitimi de mevcut.

İyi haber: Daha önce OpenAI’nin API’sini kullandıysanız, DeepSeek’i de nasıl kullanacağınızı zaten biliyorsunuz. API formatı birebir aynıdır.

Ortam kurulumu

Önce API anahtarınızı platform.deepseek.com adresinden alın. Henüz hesabınız yoksa bir hesap oluşturmanız gerekir.

Gerekli paketleri yükleyin:

uv add openai python-dotenvAltyapı:

.env dosyasını proje dizininizde oluşturup API anahtarınızı ekleyin:

DEEPSEEK_API_KEY=your_api_key_hereAltyapı:

İlk API çağrınız

İşte OpenAI SDK kullanılarak hazırlanmış basit bir örnek. OpenAI’nin API’sini kullanmaktan tek fark base_url parametresi ve kendi API anahtarınızdır:

from openai import OpenAI
from dotenv import load_dotenv
import os

# Load environment variables from .env file
load_dotenv()

# Initialize OpenAI-compatible client with DeepSeek endpoint
client = OpenAI(
   api_key=os.getenv("DEEPSEEK_API_KEY"),
   base_url="https://api.deepseek.com"
)

# Send a chat completion request to DeepSeek v3.2
response = client.chat.completions.create(
   model="deepseek-chat",
   messages=[
       {"role": "user", "content": "Explain sparse attention in one sentence."}
   ]
)

# Print the model's response
print(response.choices[0].message.content)Altyapı:

Bunu çalıştırdığınızda şöyle bir yanıt alırsınız:

Sparse attention reduces computational cost by having each token attend to only a subset of relevant tokens rather than all tokens in a sequence.Altyapı:

deepseek-chat modeli, v3.2-Exp’in düşünme dışı modudur. İsteğinizi işler ve akıl yürütme adımlarını göstermeden bir yanıt döndürür.

Akıl yürütme modelini kullanma

Modelin akıl yürütme sürecini görmek istiyorsanız, deepseek-reasoner kullanın. Bu model, nihai yanıtı vermeden önce düşünce zincirini gösterir:

# Use deepseek-reasoner to see the model's reasoning process
response = client.chat.completions.create(
   model="deepseek-reasoner",
   messages=[
       {"role": "user", "content": "Which is larger: 9.11 or 9.8?"}
   ]
)

# Print both reasoning and final answer
print("Reasoning:", response.choices[0].message.reasoning_content)
print("Answer:", response.choices[0].message.content)Altyapı:

Çıktı aşağıdakine benzer olacaktır:

Reasoning: To compare 9.11 and 9.8, I need to look at the digits after the decimal point. 9.11 has digits 1 and 1 after the decimal, making it 9 + 0.11. Meanwhile, 9.8 is 9 + 0.8. Since 0.8 is greater than 0.11, 9.8 is the larger number.

Answer: 9.8 is larger than 9.11.Altyapı:

Akıl yürütme modeli, nihai yanıtı üretmeden önce 64K token’a kadar akıl yürütme içeriği oluşturabilir (varsayılan 32K). temperature veya top_p gibi bazı parametreleri desteklemediğini unutmayın. DeepSeek’in resmi API’si henüz akıl yürütme derinliğini kontrol etmek için reasoning_effort parametresini desteklemiyor (ancak LangChain gibi bazı üçüncü taraf sağlayıcılar entegrasyonlarına ekledi).

Yanıt nesnesi OpenAI’nin yapısını izler. İçeriğe response.choices[0].message.content üzerinden erişebilir, token kullanımını response.usage ile kontrol edebilir ve kullanılan modeli response.model ile görebilirsiniz.

DeepSeek v3.2’ye erişmenin diğer yolları

API tek seçeneğiniz değil. DeepSeek, modellerini açık kaynak olarak yayımladığı için kendiniz de çalıştırabilirsiniz.

Hugging Face: Model şurada mevcut: huggingface.co/deepseek-ai/DeepSeek-V3.2-Exp. Hugging Face’in çıkarım sağlayıcılarını kullanarak altyapı yönetmeden modeli çalıştırabilir veya yerel çıkarım için ağırlıkları indirebilirsiniz. Yerel yol, donanımınız varsa işe yarar (685B parametreli bir model için veri merkezi bütçeleri ya da dolabınızda küçük bir GPU kümesi düşünün).

vLLM: Ölçekli kendi barındırma dağıtımları için vLLM, v3.2 desteğiyle optimize edilmiş çıkarım sunar. Standart transformers üzerinden modeli çalıştırmaktan daha hızlıdır ve toplu işlemeyi iyi yönetir. Bunu, modeli üretimde sunuyor ve ciddi bir altyapınız varsa kullanın.

Hangi yöntemi ne zaman kullanmalı:

• Hızlı kurulum istiyorsanız, altyapı yönetmek istemiyorsanız veya değişken iş yükleriniz varsa API’yi kullanın
• Barındırılan çıkarımın faydalarını daha fazla sağlayıcı seçeneğiyle istiyorsanız Hugging Face çıkarım sağlayıcılarını kullanın
• Tam kontrol gerekiyorsa, gizlilik gereksinimleriniz varsa veya model mimarisiyle denemeler yapmak istiyorsanız Hugging Face ağırlıklarıyla kendi başınıza barındırın
• Yüksek hacimli üretim iş yükleri çalıştırıyor ve donanım bütçeniz varsa vLLM kullanın

Yeni başlayan çoğu geliştirici için doğru seçim API’dir. Sadece kullandığınız kadar öder, ölçekleme ve bakımı DeepSeek’e bırakırsınız.

Çoklu Belge Araştırma Asistanı: Uzun Bağlam Performansının Karşılaştırılması

DeepSeek v3.2’nin API’sinin nasıl çalıştığını gördünüz ve ilk çağrılarınızı yaptınız. Şimdi bunu gerçek bir karşılaştırmayla test edelim.

DeepSeek’in seyrek dikkati uzun bağlamları işlerken gerçekten para tasarrufu sağlıyor mu? Peki GPT-5 ve Claude Sonnet 4.5 ile karşılaştırıldığında performansı nasıl?

Bunu yanıtlamak için, birden çok araştırma makalesini tek bir bağlama yükleyen ve aynı sorguyu dört modele birden gönderen bir karşılaştırma aracı oluşturacağız. Her modelin tam olarak ne kadara mal olduğunu, ne kadar hızlı yanıt verdiğini ve ne tür yanıtlar sunduğunu göreceksiniz.

Çoğu belge analiz sistemi RAG kullanır: Belgelerinizi küçük parçalara böler, gömer ve bir soru sorduğunuzda yalnızca ilgili parçaları getirir. Basit aramalar için iyi çalışır, ancak belgelerinizin farklı bölümleri arasındaki bağlantıları kaybedersiniz. Yanıtın birden fazla makaledeki ilişkileri anlamayı gerektirdiği durumlarda ne olur?

Uzun bağlam modelleri bunu her şeyi aynı anda okuyarak çözer. Parçalama yok, getirme yok, eksik bağlam yok. Tüm belgelerinizi tek bir isteme yüklersiniz ve model büyük resmi görür. Sorun maliyettir. Geleneksel dikkatle 50.000+ token’ı işlemek hızla pahalılaşır.

İşte DeepSeek’in seyrek dikkatini burada test edeceğiz. Üç araştırma makalesini (toplam yaklaşık 57.000 token) tek bir bağlama yükleyen ve dört modelin aynı sorguyu nasıl ele aldığını karşılaştıran bir uygulama oluşturacağız: GPT-5, Claude Sonnet 4.5, DeepSeek v3.2-Exp (seyrek dikkatli) ve DeepSeek v3.1-Terminus (seyrek dikkat olmayan önceki sürüm). Maliyet farklarını, yanıt sürelerini ve çıktı kalitesini yan yana göreceksiniz.

Ortaya çıkan uygulama şöyle görünüyor:

Not: Bu bölümün geri kalanı, bu uygulamanın sıfırdan nasıl oluşturulduğuna dair ayrıntılı bir döküm içerir. Karşılaştırma sonuçlarını anlamak için uygulamayı oluşturmanız gerekmez, ancak kodu adım adım incelemek, DeepSeek ile kendi uzun bağlamlı uygulamalarınızı kurmak için pratik kalıplar sunar.

Uygulamanın oluşturulması

Bunu, üç yardımcı modülle birlikte bir Streamlit uygulaması olarak inşa edeceğiz: biri belgeleri yüklemek, biri model yapılandırması, biri de sorgu işlemesi için. Uygulama akışı basit: PDF’leri yükleyin, modelleri seçin, bir soru sorun ve sonuçları karşılaştırın.

Önce bir proje dizini oluşturup bağımlılıkları yükleyin:

mkdir multi-document-qa
cd multi-document-qa
uv add streamlit langchain langchain-openai langchain-anthropic langchain-community pypdf tiktoken python-dotenv matplotlib pandasAltyapı:

.env dosyasını API anahtarlarınızla oluşturun:

OPENAI_API_KEY=your_openai_key
ANTHROPIC_API_KEY=your_anthropic_key
DEEPSEEK_API_KEY=your_deepseek_keyAltyapı:

Dikkat mekanizmaları üzerine üç araştırma makalesi indirin:

mkdir documents
cd documents
curl -L -o selective-attention.pdf "https://arxiv.org/pdf/2410.02703"
curl -L -o differential-transformer.pdf "https://arxiv.org/pdf/2410.05258"
curl -L -o sparse-attention-long-range.pdf "https://arxiv.org/pdf/2406.16747"
cd ..Altyapı:

Bu üç makale yüklendiğinde toplam 57.204 token eder.

Yükleme ve token sayımı

document_loader.py dosyasını oluşturun:

from langchain_community.document_loaders import PyPDFLoader
import tiktoken
from pathlib import Path


def load_documents(documents_dir="documents"):
   docs_path = Path(documents_dir)
   pdf_files = list(docs_path.glob("*.pdf"))
  
   all_text = ""
   document_names = []
  
   # Load each PDF and concatenate with separators
   for pdf_file in sorted(pdf_files):
       loader = PyPDFLoader(str(pdf_file))
       pages = loader.load()
       doc_text = "\n\n".join([page.page_content for page in pages])
       all_text += f"\n\n=== Document: {pdf_file.name} ===\n\n{doc_text}"
       document_names.append(pdf_file.name)Altyapı:

Bu fonksiyon, bir dizindeki tüm PDF’leri yükler, her sayfadan metni çıkarır ve belgeler arası ayraçlarla hepsini birleştirir.

# Count tokens using GPT-4 encoding (accurate across providers)
   encoding = tiktoken.encoding_for_model("gpt-4")
   token_count = len(encoding.encode(all_text))
  
   return all_text, token_count, document_namesAltyapı:

Token sayımı, sağlayıcılar genelinde benzer tokenizasyona sahip oldukları için isabetli tahminler sunan GPT-4 kodlamasıyla tiktoken kullanır. Tam document_loader.py dosyasını GitHub’da görüntüleyin.

Modellerin ve fiyatlandırmanın yapılandırılması

model_config.py dosyasını oluşturun:

from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic
import os


# Pricing per million tokens (as of October 2025)
MODEL_PRICING = {
   "gpt-5": {"input": 2.50, "output": 10.00, "name": "GPT-5"},
   "claude-sonnet-4-5-20250929": {"input": 3.00, "output": 15.00, "name": "Claude Sonnet 4.5"},
   "deepseek-chat": {"input": 0.28, "output": 0.42, "name": "DeepSeek v3.2-Exp"},
   "deepseek-chat-v3.1": {"input": 0.55, "output": 2.19, "name": "DeepSeek v3.1-Terminus"},
}Altyapı:

Fiyatlandırma sözlüğü, milyon token başına maliyetleri (Ekim 2025 itibarıyla) saklar. Seyrek dikkatli DeepSeek v3.2, GPT-5 ve Claude’a göre yaklaşık 10 kat daha ucuzken, v3.1 v3.2’nin iki katı maliyetle ortada konumlanır.

def get_model(model_name):
   """Initialize a chat model by name using LangChain's unified interface."""
   if model_name == "gpt-5":
       return ChatOpenAI(model="gpt-5", temperature=0, api_key=os.getenv("OPENAI_API_KEY"))
   elif model_name == "claude-sonnet-4-5-20250929":
       return ChatAnthropic(model="claude-sonnet-4-5-20250929", temperature=0,
                          api_key=os.getenv("ANTHROPIC_API_KEY"))
   elif model_name == "deepseek-chat":
       return ChatOpenAI(model="deepseek-chat", temperature=0,
                        api_key=os.getenv("DEEPSEEK_API_KEY"),
                        base_url="https://api.deepseek.com")
   elif model_name == "deepseek-chat-v3.1":
       # Note: v3.1-Terminus endpoint expires on October 15, 2025
       return ChatOpenAI(model="deepseek-chat", temperature=0,
                        api_key=os.getenv("DEEPSEEK_API_KEY"),
                        base_url="https://api.deepseek.com/v3.1_terminus_expires_on_20251015")


def calculate_cost(model_name, input_tokens, output_tokens):
   """Calculate total cost based on input and output token usage."""
   pricing = MODEL_PRICING[model_name]
   input_cost = (input_tokens / 1_000_000) * pricing["input"]
   output_cost = (output_tokens / 1_000_000) * pricing["output"]
   return input_cost + output_costAltyapı:

get_model() fonksiyonu, LangChain’in birleşik arayüzünü kullanarak her modeli başlatır. DeepSeek modelleri, özel temel URL’lerle OpenAI uyumlu uç noktaları kullanır. Not: v3.1-Terminus uç noktası 15 Ekim 2025’te sona eriyor. Tam model_config.py betiği GitHub’da.

Metrik takibiyle modellere sorgu gönderme

query_handler.py dosyasını oluşturun:

import time
from langchain_core.messages import SystemMessage, HumanMessage
from model_config import get_model, calculate_cost, MODEL_PRICING


def query_model(model_name, context, question):
   """Query a model with document context and track performance metrics."""
   model = get_model(model_name)
  
   # Embed full document context in system prompt
   system_prompt = f"""Use the given context to answer the question.
If you don't know the answer, say you don't know. Keep the answer concise.

Context:
{context}"""
  
   messages = [
       SystemMessage(content=system_prompt),
       HumanMessage(content=question)
   ]
  
   # Track response time
   start_time = time.time()Altyapı:

Sistem yönergesi tüm 57.000 token’lık belgeleri gömer. Geleneksel dikkat, her token’ı diğer tüm token’larla işler. DeepSeek v3.2’nin seyrek dikkati, alakasız bağlantıları atlayarak maliyeti düşürür.

try:
       response = model.invoke(messages)
       elapsed_time = time.time() - start_time
      
       # Extract token usage (different providers use different formats)
       if hasattr(response, 'response_metadata') and 'token_usage' in response.response_metadata:
           token_usage = response.response_metadata['token_usage']
           input_tokens = token_usage.get('prompt_tokens', 0)
           output_tokens = token_usage.get('completion_tokens', 0)
       elif hasattr(response, 'usage_metadata'):
           input_tokens = response.usage_metadata.get('input_tokens', 0)
           output_tokens = response.usage_metadata.get('output_tokens', 0)
      
       # Calculate total cost
       cost = calculate_cost(model_name, input_tokens, output_tokens)
      
       return {
           "model": MODEL_PRICING[model_name]["name"],
           "response": response.content,
           "input_tokens": input_tokens,
           "output_tokens": output_tokens,
           "total_tokens": input_tokens + output_tokens,
           "cost": cost,
           "time": elapsed_time,
           "error": None
       }Altyapı:

Farklı LangChain entegrasyonları, token kullanımını farklı formatlarda döndürür (OpenAI response_metadata, Anthropic usage_metadata kullanır), bu yüzden her ikisini de kontrol ederiz. Fonksiyon süreyi izler, token sayılarını çıkarır, maliyeti hesaplar ve tüm metrikleri içeren bir sözlük döndürür. Tam query_handler.py dosyasına GitHub’dan bakın.

Streamlit arayüzünü oluşturma

app.py dosyasını oluşturun:

import streamlit as st
import pandas as pd
import matplotlib.pyplot as plt
from document_loader import load_documents
from query_handler import query_model
from dotenv import load_dotenv

# Load API keys from .env file
load_dotenv()

# Configure Streamlit page with wide layout
st.set_page_config(
   page_title="Multi-Document Research Assistant",
   page_icon="📚",
   layout="wide"
)

st.title("📚 Multi-Document Research Assistant")
st.markdown("Compare long-context performance across GPT-5, Claude Sonnet 4.5, DeepSeek v3.2, and DeepSeek v3.1")Altyapı:

Yan yana karşılaştırmalar için geniş yerleşime sahip standart bir Streamlit kurulumu.

# Sidebar for document loading
with st.sidebar:
   st.header("📄 Documents Loaded")
  
   if st.button("Load Documents"):
       with st.spinner("Loading documents..."):
           # Load all PDFs and count tokens
           context, token_count, doc_names = load_documents("documents")
           st.session_state.context = context
           st.session_state.token_count = token_count
           st.session_state.doc_names = doc_names
  
   # Display loaded documents info
   if "token_count" in st.session_state:
       st.success(f"✅ Loaded {len(st.session_state.doc_names)} documents")
       st.metric("Total Tokens", f"{st.session_state.token_count:,}")
       st.write("**Documents:**")
       for name in st.session_state.doc_names:
           st.write(f"• {name}")Altyapı:

Kenar çubuğu belgeleri yükler ve token sayılarını gösterir. Streamlit’in oturum durumu, etkileşimler arasında belgelerin yüklü kalmasını sağlar.

# Main content area
if "context" not in st.session_state:
   st.info("👈 Click 'Load Documents' in the sidebar to begin")
else:
   st.subheader("Select Models to Compare")
   col1, col2, col3, col4 = st.columns(4)
  
   # Model selection checkboxes
   with col1:
       use_gpt5 = st.checkbox("GPT-5", value=True)
   with col2:
       use_claude = st.checkbox("Claude Sonnet 4.5", value=True)
   with col3:
       use_deepseek_v32 = st.checkbox("DeepSeek v3.2-Exp", value=True)
   with col4:
       use_deepseek_v31 = st.checkbox("DeepSeek v3.1-Terminus", value=True)
  
   # Sample questions for quick testing
   sample_questions = [
       "Compare the main approaches to attention mechanisms described in these documents",
       "What are the key differences between sparse and dense attention?",
       "Summarize the common themes across all documents"
   ]Altyapı:

Model seçimi için dört onay kutusu ve ön tanımlı örnek sorular.

# Question input with samples
   question_choice = st.selectbox(
       "Select a sample question or write your own:",
       ["Custom"] + sample_questions
   )
  
   if question_choice == "Custom":
       question = st.text_area("Enter your question:", height=100)
   else:
       question = st.text_area("Enter your question:", value=question_choice, height=100)
  
   # Query button and model execution
   if st.button("🚀 Query Models", type="primary"):
       if not question:
           st.error("Please enter a question")
       else:
           # Build list of selected models
           selected_models = []
           if use_gpt5:
               selected_models.append("gpt-5")
           if use_claude:
               selected_models.append("claude-sonnet-4-5-20250929")
           if use_deepseek_v32:
               selected_models.append("deepseek-chat")
           if use_deepseek_v31:
               selected_models.append("deepseek-chat-v3.1")Altyapı:

Kullanıcılar bir soru seçer ya da yazar ve “Query Models”e tıklayarak seçili modeller üzerinde karşılaştırmayı çalıştırır.

results = []
          
           # Query each model sequentially with progress indicator
           for model_name in selected_models:
               with st.spinner(f"Querying {model_name}..."):
                   result = query_model(
                       model_name,
                       st.session_state.context,
                       question
                   )
                   results.append(result)
          
           # Store results in session state for persistence
           st.session_state.results = resultsAltyapı:

Her model bir ilerleme göstergesi eşliğinde sırayla sorgulanır.

# Display results if available
if "results" in st.session_state:
   st.divider()
   st.subheader("📊 Results")
  
   results = st.session_state.results
  
   # Show model responses in expandable panels
   st.markdown("### Responses")
   for result in results:
       with st.expander(f"**{result['model']}** - ${result['cost']:.4f} | {result['time']:.2f}s"):
           if result['error']:
               st.error(f"Error: {result['error']}")
           else:
               st.write(result['response'])
  
   # Create metrics comparison table
   metrics_df = pd.DataFrame([
       {
           "Model": r['model'],
           "Input Tokens": r['input_tokens'],
           "Output Tokens": r['output_tokens'],
           "Total Tokens": r['total_tokens'],
           "Cost ($)": f"${r['cost']:.4f}",
           "Time (s)": f"{r['time']:.2f}"
       }
       for r in results
   ])
  
   st.dataframe(metrics_df, use_container_width=True)Altyapı:

Sonuçlar, başlıkta maliyet ve süre bulunan genişletilebilir panellerde her modelin yanıtıyla gösterilir; ardından sıralanabilir bir metrikler tablosu gelir.

# Create visualization charts
   fig, axes = plt.subplots(2, 2, figsize=(12, 10))
  
   # Chart 1: Cost comparison bar chart
   axes[0, 0].bar([r['model'] for r in results], [r['cost'] for r in results],
                  color=['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728'][:len(results)])
   axes[0, 0].set_title('Cost Comparison')
   axes[0, 0].set_ylabel('Cost ($)')
   axes[0, 0].tick_params(axis='x', rotation=45)
  
   # Chart 2: Response time bar chart
   axes[0, 1].bar([r['model'] for r in results], [r['time'] for r in results],
                  color=['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728'][:len(results)])
   axes[0, 1].set_title('Response Time Comparison')
   axes[0, 1].set_ylabel('Time (seconds)')
  
   # Chart 3: Token usage grouped bar chart
   models = [r['model'] for r in results]
   input_tokens = [r['input_tokens'] for r in results]
   output_tokens = [r['output_tokens'] for r in results]
   x = range(len(models))
   width = 0.35
   axes[1, 0].bar([i - width/2 for i in x], input_tokens, width, label='Input', color='#1f77b4')
   axes[1, 0].bar([i + width/2 for i in x], output_tokens, width, label='Output', color='#ff7f0e')
   axes[1, 0].set_title('Token Usage Comparison')
   axes[1, 0].legend()Altyapı:

2x2 ızgarada dört matplotlib grafiği: maliyet çubukları, süre çubukları, gruplanmış token kullanımı çubukları ve maliyet-zaman saçılım grafiği.

# Chart 4: Cost vs time tradeoff scatter plot
   axes[1, 1].scatter([r['cost'] for r in results], [r['time'] for r in results],
                      s=100, alpha=0.6, color=['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728'][:len(results)])
   for i, r in enumerate(results):
       axes[1, 1].annotate(r['model'], (r['cost'], r['time']), fontsize=8, ha='right')
   axes[1, 1].set_title('Cost vs Time Trade-off')
   axes[1, 1].set_xlabel('Cost ($)')
   axes[1, 1].set_ylabel('Time (seconds)')
   axes[1, 1].grid(True, alpha=0.3)
  
   plt.tight_layout()
   st.pyplot(fig)
  
   # Display key findings
   if len(results) > 1:
       cheapest = min(results, key=lambda x: x['cost'])
       fastest = min(results, key=lambda x: x['time'])
      
       col1, col2 = st.columns(2)
       with col1:
           st.metric("Most Cost-Effective", cheapest['model'], f"${cheapest['cost']:.4f}")
       with col2:
           st.metric("Fastest Response", fastest['model'], f"{fastest['time']:.2f}s")Altyapı:

Temel bulgular, otomatik olarak en ucuz ve en hızlı modelleri vurgular. Tam app.py dosyasını GitHub’da görüntüleyin.

Karşılaştırmayı çalıştırma

Uygulamayı başlatın:

streamlit run app.pyAltyapı:

Üç PDF’yi yüklemek için “Load Documents”a tıklayın (toplam 57.204 token). Karşılaştırılacak modelleri seçin (varsayılan olarak dördü birden), bir soru seçin veya yazın ve ardından “Query Models”a tıklayın.

57.000 token’lık bağlam için beklenen yanıt süreleri:

• Claude Sonnet 4.5: 15–20 saniye
• DeepSeek v3.2: 30–35 saniye
• DeepSeek v3.1: 35–40 saniye
• GPT-5: 40–45 saniye

Sonuçlar: Maliyet ve performans analizi

GPT-5, 42,28 saniyede 56.937 giriş token’ı işledi ve 1.996 çıkış token’ı üretti; maliyet $0,1623. Claude Sonnet 4.5, 16,13 saniyede 65.855 giriş token’ı işledi ve 485 çıkış token’ı üretti — en hızlı ama en pahalı. DeepSeek v3.2-Exp, 32,16 saniyede yalnızca $0,0162 maliyetle 56.842 giriş token’ı işledi ve 698 çıkış token’ı üretti. DeepSeek v3.1-Terminus ise 35,85 saniyede 56.842 giriş ve 700 çıkış token’ı için $0,0328 tuttu.

v3.1 ile v3.2 arasındaki karşılaştırma, seyrek dikkatin etkisini gösteriyor. Her ikisi de aynı girdileri işledi ve neredeyse aynı çıktıları üretti (698’e karşı 700 token), ancak v3.2 yarı maliyetliydi ($0,0162’ya karşı $0,0328) ve biraz daha hızlıydı (32,16 sn’ye karşı 35,85 sn). Bu, yalnızca seyrek dikkatten kaynaklı 2 kat maliyet düşüşüdür.

GPT-5 ve Claude ile karşılaştırıldığında, v3.2 GPT-5’ten 10 kat daha ucuzdur ($0,0162’ya karşı $0,1623) ve Claude’dan 13 kat daha ucuzdur ($0,0162’ya karşı $0,2048). Bu uzunlukta 100 sorguda, DeepSeek v3.2 ile $16,20 harcarken GPT-5 ile $162,30, Claude ile $204,80 harcarsınız.

Grafikler, maliyet-zaman dengesi diyagramında DeepSeek v3.2’nin sol alt çeyrekteki konumunu doğruluyor: 32 saniyede makul hızı korurken $0,0162 ile en ucuz. Claude, hız için maliyetten feragat ediyor (pahalı ama en hızlı), GPT-5 her iki metrikte de geride kalıyor (pahalı ve en yavaş) ve v3.1 ortada yer alıyor. Token kullanımı grafiği tüm modellerin benzer giriş boyutlarını işlediğini, ancak çıktı uzunluklarının değiştiğini gösteriyor — GPT-5 1.996 token ile en uzun yanıtı üretirken, Claude 485 token ile kısa tuttu; her iki DeepSeek sürümü ise yaklaşık 700 token civarında benzer çıktılar üretti.

Bu yaklaşım ne zaman mantıklıdır?

Tam belgeleri bağlama yüklemek, belgeler arası anlayış gerektiğinde en iyi sonucu verir. Sorunuz üç farklı makaledeki fikirleri birbirine bağlamayı gerektiriyorsa, parçalama ve getirme bu bağlantıları kaçırabilir. Modelin her şeyi bir arada görmesi gerekir.

Bu desen şu kullanım durumlarına uyuyor:

• Araştırma ve analiz: İlişkilerin, belirli gerçekleri bulmaktan daha önemli olduğu birden fazla makale, rapor veya yazının karşılaştırılması.
• Hukuki belge incelemesi: Sözleşme karşılaştırması, politika analizi veya düzenleyici incelemeler gibi bağlamın ve ince farkların önemli olduğu durumlar.
• Teknik dokümantasyon: Farklı API dokümanlarının veya teknik şartnamelerin birbiriyle nasıl ilişkili olduğunu anlamak.
• Uzun biçimli içerik üretimi: Her bir kaynağın ne söylediğinin farkında olarak, birden çok kaynaktan bilgiyi sentezleyen yazım.

Yaklaşım şu durumlarda iyi çalışmaz:

• Belgeler çok büyükse: Çoğu model 128K–200K token ile sınırlıdır. Belgeleriniz bu sınırı aşıyorsa parçalama gerekir.
• Gerçek arıyorsanız: Belirli bir bölümde var olduğunu bildiğiniz “X’in yanıtını bul” türü sorgularda getirmeli RAG daha iyidir.
• Çok sayıda belgeniz varsa: 20 belgeyi tam uzunlukta yüklemek bağlam sınırlarını aşabilir. Yüklemeden önce belgeleri filtreleyen hibrit yaklaşımları düşünün.
• Bütçe sınırsızsa: Maliyet önemli değilse, karmaşık sorgularda GPT-5 veya Claude biraz daha iyi yanıtlar verebilir.

DeepSeek’in seyrek dikkati, uzun bağlam işlemenin ekonomisini değiştiriyor. Eskiden sorgu başına $0,15–0,20 tutan şey şimdi $0,01–0,02 tutuyor. Bu da günde yüzlerce veya binlerce sorgu çalıştıran uygulamalar için tam bağlamlı yaklaşımları pratik hale getiriyor.

Sonuç

DeepSeek v3.2’nin seyrek dikkati, v3.1’e göre aynı model kalitesini yarı maliyetle sunuyor. Oluşturduğumuz çoklu belge karşılaştırması bunu pratikte gösterdi. 57.000 token’ı işlemek v3.2 ile $0,0162 tutarken v3.1 ile $0,0328 tuttu ve her ikisi de neredeyse aynı çıktıları üretti. GPT-5 ve Claude ile karşılaştırıldığında v3.2, makul yanıt sürelerini korurken 10–13x daha ucuz. Düzenli olarak uzun bağlam işleyen uygulamalarda bu tasarruflar hızla birikiyor.

Belge analizi, araştırma araçları veya uzun bağlamlarla uğraşan herhangi bir uygulama üzerinde çalışıyorsanız, v3.2’yi denemeye değer. Yine de deneysel olduğunu unutmayın; üretime almadan önce test edin.

Yapay zekâdaki en yeni gelişmeler hakkında daha fazla bilgi edinmek için şu bloglara göz atın:

• Claude Sonnet 4.5: Testler, Özellikler, Erişim, Kıyaslamalar ve Daha Fazlası
• Sora 2: Örnekler, Eleştiriler ve İlk İzlenimler
• Imagine with Claude: Uygulamalı Örneklerle Bir Rehber