DeepSeek V3.2: een gids met demoproject

DeepSeek heeft zojuist v3.2-Exp uitgebracht, een experimenteel model dat de API-kosten met meer dan de helft verlaagt. Als je met large language models werkt, weet je dat lang-contextverwerking snel duur wordt. Deze nieuwe release pakt dat probleem aan met een techniek genaamd DeepSeek Sparse Attention.

In deze tutorial leg ik uit wat v3.2 anders maakt dan eerdere DeepSeek-versies, hoe sparse attention onder de motorkap werkt en hoe je het model in je projecten gebruikt. We behandelen de basis van API-calls en bouwen een demoproject dat laat zien waar dit model het best tot zijn recht komt.

Aan het einde bouw je een Streamlit-app die kosten vergelijkt tussen verschillende LLM’s, waaronder DeepSeek v3.2:

Ik raad je ook aan om ons demoproject te bekijken over de nieuwe DeepSeek-V3.2-Speciale-variant. 

Wat is DeepSeek V3.2?

Laten we beginnen met wat achtergrond over DeepSeek en wat er in deze release is veranderd.

De DeepSeek-modelfamilie

DeepSeek is een open-source AI-bedrijf uit China dat large language models bouwt onder de MIT-licentie. Hun modellen concurreren met GPT-5 en Claude op het gebied van redeneren, coderen en algemene taken. Het bedrijf bracht het afgelopen jaar verschillende versies uit, waaronder DeepSeek-V3 en DeepSeek-R1, die de aandacht trokken door sterke prestaties tegen lagere kosten dan gesloten alternatieven.

Voor v3.2 was de meest recente release v3.1-Terminus, een model met 685 miljard parameters. Hoewel het solide presteerde, bleef het verwerken van lange contexten duur. Daar komt de nieuwe experimentele release om de hoek kijken.

V3.2-Exp: de experimentele release

DeepSeek bracht v3.2-Exp uit op 29 september 2025 (2025-09-29). De "Exp" staat voor experimenteel, wat betekent dat het model nog wordt getest en verfijnd. Reken nog niet op productiestabiliteit, maar je kunt het wel gebruiken voor onderzoek en projecten waarin je de nieuwste features wilt uitproberen.

Het model is gebouwd op v3.1-Terminus en behoudt dezelfde architectuur met 685B parameters. Het verschil zit in hoe het intern informatie verwerkt. Het gebruikt een OpenAI-compatibel API-formaat, dus als je eerder met de OpenAI SDK hebt gewerkt, weet je al hoe je met DeepSeek werkt (ik laat in dit artikel ook zien hoe je je eerste API-call doet).

De belangrijkste innovatie: kosten en efficiëntie

Hier is de grote verandering: DeepSeek verlaagde de API-prijzen met meer dan 50% vergeleken met v3.1. En de prestaties bleven gelijk. Je krijgt dezelfde kwaliteit antwoorden voor de helft van de kosten.

Deze prijsdaling komt door een technische verbetering genaamd DeepSeek Sparse Attention (DSA). In plaats van dat het model elk token in je input aandacht geeft (wat rekenintensief is), focust DSA selectief op wat ertoe doet. In de volgende sectie kijken we hoe dat werkt.

Als je alle technische details wilt, publiceerde DeepSeek een technisch rapport op GitHub waarin de architectuurwijzigingen en benchmarkresultaten worden uitgelegd.

Wat is DeepSeek Sparse Attention (DSA)?

Voordat we naar de code gaan, kijken we naar wat v3.2 goedkoper en sneller maakt. Het antwoord zit in hoe het model je input verwerkt.

Attentionmechanismen in transformers: een korte introductie

Wanneer je tekst naar een taalmodel stuurt, splitst het je input in tokens (grofweg woorden of delen van woorden). Het model moet dan bepalen welke tokens met elkaar samenhangen. Dat proces heet attention.

In traditionele transformers kijkt elk token naar elk ander token. Als je 1.000 tokens hebt, bekijkt elk token de andere 999. Dat zijn 1 miljoen vergelijkingen. Bij 10.000 tokens kom je uit op 100 miljoen vergelijkingen. De rekenlast is kwadratisch: verdubbel je invoerlengte en je verviervoudigt de rekentijd.

Daarom is lang-contextverwerking duur. Je API-rekening groeit snel naarmate je documenten langer worden.

Wat sparse attention betekent

Niet alle tokens hoeven naar alle andere tokens te kijken. Als je deze zin leest, herlees je niet constant elk eerder woord. Je focust op wat relevant is.

Sparse attention doet hetzelfde. In plaats van elk token met elk ander token te vergelijken, kiest het model selectief welke vergelijkingen ertoe doen. Enkele oudere benaderingen zijn:

• Block-sparse attention: Verdeel tokens in blokken en laat blokken alleen naar nabijgelegen blokken kijken
• Local window attention: Elk token kijkt alleen naar tokens binnen een vaste afstand

Deze methoden besparen rekenkracht, maar zijn star. Ze bepalen vooraf welke tokens mogen interacteren, ongeacht je daadwerkelijke tekst. Soms moet een woord aan het begin van een document verbinden met iets aan het eind. Vaste patronen kunnen dat missen.

DeepSeek Sparse Attention (DSA): een fijnmazige aanpak

DSA kiest een andere route. In plaats van vaste patronen leert het welke tokens daadwerkelijk naar elkaar moeten kijken op basis van de inhoud zelf. Het model kiest on the fly relevante verbindingen.

Zo werkt het op hoofdlijnen. Tijdens de training voegde DeepSeek een selectiemechanisme toe aan elke attentionlaag. Dit mechanisme bekijkt je tokens en beslist welke attentionverbindingen de moeite waard zijn om te berekenen. Het behoudt de belangrijke en slaat de rest over.

De selectie is niet willekeurig. Het model leerde tijdens de training welke soorten verbindingen ertoe doen voor verschillende taken. Als je een prompt over code stuurt, focust het op andere patronen dan bij een juridisch document.

Het resultaat: DSA vermindert het aantal attention-bewerkingen zonder de outputkwaliteit te schaden. In het technisch rapport laat DeepSeek zien dat v3.2 vrijwel identiek presteert aan v3.1-Terminus op benchmarks, terwijl er minder berekeningen per token nodig zijn. Je krijgt dezelfde modelkwaliteit tegen ongeveer de helft van de API-kosten.

Waarom dit belangrijk is voor developers

Dit betekent DSA in de praktijk:

• Lagere API-kosten: je betaalt minder voor dezelfde kwaliteit van antwoorden
• Betere lang-contextverwerking: het model ondersteunt een contextvenster van 128K tokens en verwerkt deze langere inputs goedkoper dan modellen zonder sparse attention
• Snellere inferentie: minder bewerkingen betekent kortere reactietijden

De voordelen komen vooral naar voren bij deze use-cases:

• Tegelijkertijd meerdere documenten analyseren
• Context behouden in lange gesprekken
• Grote codebases of technische documenten verwerken
• Onderzoeksartikelen of contracten samenvatten

Als je applicatie met lange inputs werkt, maakt DSA echt verschil. Je bespaart niet alleen geld. Je krijgt ook betere prestaties bij taken waar traditionele attention moeite mee heeft.

Je eerste DeepSeek V3.2-call maken

Nu je begrijpt hoe DSA werkt, gebruiken we het model via de API.

Vereisten

Je hebt Python 3.8 of nieuwer nodig op je machine. Als je nieuw bent met LLM’s via API’s, kijk dan even naar DataCamps gids over hoe je AI leert om de basis te leren. We hebben ook een uitgebreidere DeepSeek API-tutorial die eerdere versies behandelt als je dieper wilt gaan.

Het goede nieuws: als je de API van OpenAI al hebt gebruikt, kun je ook meteen met DeepSeek overweg. Het API-formaat is identiek.

Omgevingsconfiguratie

Haal eerst je API-sleutel op via platform.deepseek.com. Je moet een account aanmaken als je dat nog niet hebt.

Installeer de benodigde packages:

uv add openai python-dotenvMogelijk gemaakt door

Maak een .env-bestand in je projectmap en voeg je API-sleutel toe:

DEEPSEEK_API_KEY=your_api_key_hereMogelijk gemaakt door

Je eerste API-call

Hier is een basisvoorbeeld met de OpenAI SDK. Het enige verschil met de API van OpenAI is de parameter base_url en je API-sleutel:

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)Mogelijk gemaakt door

Als je dit uitvoert, krijg je een antwoord zoals:

Sparse attention reduces computational cost by having each token attend to only a subset of relevant tokens rather than all tokens in a sequence.Mogelijk gemaakt door

Het deepseek-chat-model is de non-thinking-modus van v3.2-Exp. Het verwerkt je verzoek en geeft een antwoord zonder zijn redeneerstappen te tonen.

Het reasoning-model gebruiken

Als je het redeneerproces van het model wilt zien, gebruik dan deepseek-reasoner. Dit model toont zijn chain of thought voordat het je het eindantwoord geeft:

# 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)Mogelijk gemaakt door

Dit geeft iets als output:

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.Mogelijk gemaakt door

Het reasoning-model kan tot 64K tokens aan redeneerinhoud genereren (standaard 32K) voordat het het eindantwoord produceert. Let op dat het sommige parameters zoals temperature of top_p niet ondersteunt. De officiële API van DeepSeek ondersteunt nog geen parameter reasoning_effort om de redeneerdiepte te sturen (al hebben sommige derden zoals LangChain het aan hun integraties toegevoegd).

Het response-object volgt de structuur van OpenAI. Je kunt de content benaderen via response.choices[0].message.content, het tokengebruik checken met response.usage en het gebruikte model zien met response.model.

Andere manieren om DeepSeek v3.2 te gebruiken

De API is niet je enige optie. DeepSeek brengt zijn modellen als open source uit, dus je kunt ze zelf draaien.

Hugging Face: het model is beschikbaar op huggingface.co/deepseek-ai/DeepSeek-V3.2-Exp. Je kunt de inference-providers van Hugging Face gebruiken om het model te draaien zonder zelf infrastructuur te beheren, of de weights downloaden voor lokale inference. De lokale route werkt goed als je de hardware hebt (denk aan datacenterbudgetten of een kleine GPU-farm in je kast voor een model met 685B parameters).

vLLM: voor grootschalige self-hosted deployments biedt vLLM geoptimaliseerde inference met ondersteuning voor v3.2. Het is sneller dan het model via standaard transformers draaien en gaat goed om met batching. Gebruik dit als je het model in productie serveert en serieuze infrastructuur hebt.

Wanneer gebruik je welke methode:

• Gebruik de API als je snel wilt starten, geen infrastructuur wilt beheren of wisselende workloads hebt
• Gebruik Hugging Face-inferenceproviders als je de voordelen van hosted inference wilt met meer provideropties
• Self-host via Hugging Face-weights als je volledige controle nodig hebt, privacy-eisen hebt of met de modelarchitectuur wilt experimenteren
• Gebruik vLLM als je high-volume productieworkloads draait en een passend hardwarebudget hebt

Voor de meeste developers die beginnen is de API de juiste keuze. Je betaalt alleen voor wat je gebruikt en DeepSeek regelt schaal en onderhoud.

Multi-Document Research Assistant: lang-contextprestaties vergelijken

Je hebt gezien hoe de API van DeepSeek v3.2 werkt en je eerste calls gemaakt. Laten we het nu in de praktijk testen met een vergelijking in de echte wereld.

Bespaart de sparse attention van DeepSeek daadwerkelijk geld bij het verwerken van lange contexten? En hoe verhoudt het zich tot GPT-5 en Claude Sonnet 4.5?

Om dit te beantwoorden bouwen we een vergelijkingstool die meerdere onderzoeksartikelen in één context laadt en dezelfde query naar alle vier de modellen stuurt. Je ziet precies hoeveel elk model kost, hoe snel het reageert en wat voor antwoorden het geeft.

De meeste documentsystemen gebruiken RAG: ze hakken je documenten in stukken, embedden ze en halen alleen de relevante stukken op wanneer je een vraag stelt. Dit werkt goed voor simpele opzoekvragen, maar je verliest verbanden tussen verschillende delen van je documenten. Wat als het antwoord begrip vereist over relaties tussen meerdere artikelen?

Lang-contextmodellen lossen dit op door alles in één keer te lezen. Geen chunks, geen retrieval, geen ontbrekende context. Je laadt al je documenten in één prompt en laat het model het volledige plaatje zien. Het probleem is de kosten. Met traditionele attention wordt het verwerken van 50.000+ tokens snel duur.

Hier testen we de sparse attention van DeepSeek. We bouwen een applicatie die drie onderzoeksartikelen (ongeveer 57.000 tokens totaal) in één context laadt en vergelijkt hoe vier modellen dezelfde query afhandelen: GPT-5, Claude Sonnet 4.5, DeepSeek v3.2-Exp (met sparse attention) en DeepSeek v3.1-Terminus (de vorige versie zonder sparse attention). Je ziet kostenverschillen, reactietijden en outputkwaliteit naast elkaar.

Zo ziet de uiteindelijke applicatie eruit:

Let op: de rest van deze sectie bevat een gedetailleerde uitleg om deze applicatie from scratch te bouwen. Je hoeft hem niet te bouwen om de vergelijkingsresultaten te begrijpen, maar door de code te lopen krijg je praktische patronen voor je eigen lang-contextapplicaties met DeepSeek.

De applicatie bouwen

We bouwen dit als een Streamlit-app met drie ondersteunende modules: één voor het laden van documenten, één voor modelconfiguratie en één voor het afhandelen van vragen. De flow is simpel: PDF’s laden, modellen selecteren, een vraag stellen en resultaten vergelijken.

Begin met het aanmaken van een projectmap en het installeren van dependencies:

mkdir multi-document-qa
cd multi-document-qa
uv add streamlit langchain langchain-openai langchain-anthropic langchain-community pypdf tiktoken python-dotenv matplotlib pandasMogelijk gemaakt door

Maak een .env-bestand met je API-sleutels:

OPENAI_API_KEY=your_openai_key
ANTHROPIC_API_KEY=your_anthropic_key
DEEPSEEK_API_KEY=your_deepseek_keyMogelijk gemaakt door

Download drie onderzoeksartikelen over attentionmechanismen:

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 ..Mogelijk gemaakt door

Deze drie papers zijn samen 57.204 tokens wanneer ze geladen zijn.

Tokens laden en tellen

Maak document_loader.py aan:

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)Mogelijk gemaakt door

De functie laadt alle PDF’s uit een map, extraheert tekst van elke pagina en voegt alles samen met documentseparators.

# 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_namesMogelijk gemaakt door

Het tellen van tokens gebruikt tiktoken met GPT-4-encoding, wat nauwkeurige schattingen geeft tussen providers omdat ze vergelijkbare tokenization gebruiken. Bekijk het volledige document_loader.py op GitHub.

Modellen en prijzen configureren

Maak model_config.py aan:

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"},
}Mogelijk gemaakt door

De prijzendictionary bevat kosten per miljoen tokens (per oktober 2025). DeepSeek v3.2 met sparse attention is ongeveer 10x goedkoper dan GPT-5 en Claude, terwijl v3.1 in het midden zit op 2x de kosten van v3.2.

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_costMogelijk gemaakt door

De functie get_model() initialiseert elk model via de uniforme interface van LangChain. DeepSeek-modellen gebruiken OpenAI-compatibele endpoints met aangepaste base-URL’s. Let op: het v3.1-Terminus-endpoint verloopt op 15 oktober 2025. Het volledige script model_config.py staat op GitHub.

Modellen bevragen met metriektracking

Maak query_handler.py aan:

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()Mogelijk gemaakt door

De systemprompt embedt alle 57.000 tokens aan documenten. Traditionele attention verwerkt elk token tegen elk ander token. De sparse attention van DeepSeek v3.2 slaat irrelevante verbindingen over en verlaagt zo de kosten.

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
       }Mogelijk gemaakt door

Verschillende LangChain-integraties geven het tokenverbruik in verschillende formaten terug (OpenAI gebruikt response_metadata, Anthropic gebruikt usage_metadata), dus we controleren beide. De functie houdt tijd bij, haalt aantallen tokens op, berekent kosten en retourneert een dictionary met alle statistieken. Bekijk de volledige query_handler.py op GitHub.

De Streamlit-interface bouwen

Maak app.py aan:

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")Mogelijk gemaakt door

Standaard Streamlit-setup met een brede lay-out voor vergelijkingen naast elkaar.

# 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}")Mogelijk gemaakt door

De zijbalk laadt documenten en toont tokenaantallen. De session state van Streamlit houdt documenten geladen tussen interacties.

# 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"
   ]Mogelijk gemaakt door

Vier selectievakjes voor modelkeuze en vooraf gedefinieerde voorbeeldvragen.

# 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")Mogelijk gemaakt door

Gebruikers kiezen een vraag of schrijven hun eigen vraag en klikken daarna op "Query Models" om de vergelijking op de geselecteerde modellen uit te voeren.

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 = resultsMogelijk gemaakt door

Elk model wordt achtereenvolgens bevraagd met een spinner die de voortgang toont.

# 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)Mogelijk gemaakt door

Resultaten tonen de reactie van elk model in uitklapbare panelen met kosten en tijd in de kop, gevolgd door een sorteerbare tabel met statistieken.

# 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()Mogelijk gemaakt door

Vier matplotlib-grafieken in een 2x2-raster: kostengrafiek, tijdbalken, gegroepeerde tokengebruik-balken en een scatterplot van kosten versus tijd.

# 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")Mogelijk gemaakt door

Belangrijkste bevindingen lichten automatisch de goedkoopste en snelste modellen uit. Bekijk de volledige app.py op GitHub.

De vergelijking uitvoeren

Start de app:

streamlit run app.pyMogelijk gemaakt door

Klik op "Load Documents" om de drie pdf’s te laden (in totaal 57.204 tokens). Selecteer modellen om te vergelijken (standaard alle vier), kies of schrijf een vraag en klik daarna op "Query Models".

Verwachte responstijden voor een context van 57.000 tokens:

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

Resultaten: kosten- en prestatieanalyse

GPT-5 verwerkte 56.937 inputtokens en genereerde 1.996 outputtokens voor $0,1623 in 42,28 seconden. Claude Sonnet 4.5 verwerkte 65.855 inputtokens en genereerde 485 outputtokens voor $0,2048 in 16,13 seconden — snelst maar het duurst. DeepSeek v3.2-Exp verwerkte 56.842 inputtokens en genereerde 698 outputtokens voor slechts $0,0162 in 32,16 seconden. DeepSeek v3.1-Terminus verwerkte 56.842 inputtokens en genereerde 700 outputtokens voor $0,0328 in 35,85 seconden.

De vergelijking tussen v3.1 en v3.2 laat het effect van sparse attention zien. Beide verwerkten identieke inputs en produceerden bijna identieke outputs (698 vs. 700 tokens), maar v3.2 kostte de helft ($0,0162 vs. $0,0328) en was iets sneller (32,16s vs. 35,85s). Dat is een 2x kostenreductie puur door sparse attention.

Vergeleken met GPT-5 en Claude is v3.2 10x goedkoper dan GPT-5 ($0,0162 vs. $0,1623) en 13x goedkoper dan Claude ($0,0162 vs. $0,2048). Over 100 queries van deze lengte zou je $16,20 uitgeven met DeepSeek v3.2 tegenover $162,30 met GPT-5 of $204,80 met Claude.

De grafieken bevestigen de positie van DeepSeek v3.2 in het kwadrant linksonder van de afruil kosten versus tijd: algeheel het goedkoopst met $0,0162 en toch redelijk snel met 32 seconden. Claude ruilt kosten in voor snelheid (duur maar het snelst), GPT-5 loopt op beide metrics achter (duur en het traagst) en v3.1 zit in het midden. De tokengrafiek laat zien dat alle modellen vergelijkbare inputgroottes verwerken, maar de outputlengtes variëren — GPT-5 genereerde het langste antwoord met 1.996 tokens, Claude hield het kort met 485 tokens en beide DeepSeek-versies produceerden vergelijkbare outputs rond 700 tokens.

Wanneer deze aanpak zinvol is

Volledige documenten in de context laden werkt het best wanneer je begrip over meerdere documenten nodig hebt. Als je vraag verbanden tussen drie verschillende papers vereist, kunnen chunking en retrieval die verbindingen missen. Het model moet alles tegelijk zien.

Dit patroon past bij verschillende use-cases:

• Onderzoek en analyse: meerdere papers, rapporten of artikelen vergelijken waarbij relaties belangrijker zijn dan losse feiten vinden.
• Juridische documentreview: contractvergelijking, beleidsanalyse of toetsing aan regelgeving waarbij context en subtiele verschillen belangrijk zijn.
• Technische documentatie: begrijpen hoe verschillende API-docs of technische specificaties zich tot elkaar verhouden.
• Longform-contentcreatie: schrijven dat informatie uit meerdere bronnen synthetiseert en tegelijk bijhoudt wat elke bron zegt.

De aanpak werkt minder goed wanneer:

• Documenten te groot zijn: de meeste modellen hebben een limiet van 128K–200K tokens. Als je documenten daar overheen gaan, heb je chunking nodig.
• Je feiten zoekt: RAG met retrieval werkt beter voor “zoek het antwoord op X”-vragen waarbij je weet dat de info in een specifiek gedeelte staat.
• Je veel documenten hebt: 20 documenten volledig laden kan de contextlimiet overschrijden. Overweeg hybride aanpakken die documenten filteren voordat je laadt.
• Budget onbeperkt is: als kosten niet uitmaken, leveren GPT-5 of Claude mogelijk iets betere reacties bij complexe vragen.

De sparse attention van DeepSeek verandert de economische kant van long-contextverwerking. Wat eerder $0,15–0,20 per query kostte, kost nu $0,01–0,02. Daardoor worden full-contextbenaderingen praktisch voor toepassingen die dagelijks honderden of duizenden queries draaien.

Conclusie

De sparse attention van DeepSeek v3.2 levert dezelfde modelkwaliteit tegen de helft van de kosten van v3.1. De multidocumentvergelijking die we bouwden liet dit in de praktijk zien. Het verwerken van 57.000 tokens kostte $0,0162 met v3.2 tegenover $0,0328 met v3.1, en beide produceerden vrijwel identieke outputs. Vergeleken met GPT-5 en Claude is v3.2 10–13x goedkoper, terwijl de responstijden redelijk blijven. Voor toepassingen die regelmatig lange contexten verwerken, lopen die besparingen snel op.

Werk je aan documentanalyse, researchtools of een applicatie die met lange contexten omgaat, dan is v3.2 het testen waard. Onthoud wel dat het nog experimenteel is, dus test goed voordat je het in productie zet.

Wil je meer leren over het laatste in AI, bekijk dan deze blogs:

• Claude Sonnet 4.5: Tests, functies, toegang, benchmarks en meer
• Sora 2: voorbeelden, kritieken en eerste indrukken
• Imagine with Claude: een gids met praktische voorbeelden