Qwen 3.7 Max API Eğitimi: Kendi Kendini Gözden Geçiren Bir Üretkenlik Aracısı Oluşturun

Qwen 3.7 Max nedir?

Qwen 3.7 Max, 20 Mayıs 2026’da yayımlanan Alibaba’nın yeni amiral gemisi modelidir. Agentik iş akışları için geliştirilmiştir. Bu şu anlama gelir: yalnızca tek seferlik sohbet için tasarlanmak yerine, planlama, araç kullanımı, kodlama, ofis otomasyonu, uzun bağlamlı akıl yürütme ve çok adımlı yürütme gerektiren görevler için optimize edilmiştir. 

Qwen ekibi, modeli “agent çağı” için bir model olarak tanımlıyor; kodlama ajanları, üretkenlik asistanları, MCP tabanlı iş akışları ve uzun ufuklu otonom görevlerde güçlüdür.

Bu modelin ilginç yanı yalnızca ham karşılaştırma performansı değil; her bir turu farklı bir amaca hizmet eden çok turlu bir görev boyunca tutarlı kalabilmesidir; buna şunlar dahildir:

• planlama
• kanıt sentezi
• uzun biçimli yazma
• öz-eleştiri
• revizyon

X’te kullanıcılar, modelin uzun ufuklu kodlama görevlerinde Opus 4.7 ve GPT 5.5 ile başa baş olduğunu buldu.

Qwen 3.7 Max’in güçlü yönleri ve karşılaştırma performansı

Qwen 3.7 Max, agent ve akıl yürütme kıyaslarında güçlü performans sergiler. Kodlama-ajansı değerlendirmelerinde şu puanları alır: 

• Terminal-Bench 2.0-Terminus’ta 69,7
• SWE-bench Pro’da 60,6
• SWE-bench Multilingual’de 78,3
• NL2Repo’da 47,2
• SciCode’da 53,5

Genel-ajans kıyaslarında ise şu seviyelere ulaşır: 

• MCP-Mark’ta 60,8
• MCP-Atlas’ta 76,4
• CoWorkBench’te 67,2
• SpreadSheetBench-v1’de 87,0

Kaynak: Qwen geliştirici blogu

Bunun ne anlama geldiğine dair bir fikir vermek gerekirse: tüm bu sonuçlar DeepSeek V4 Pro’nun puanlarının önündedir; çoğu az farkla, ancak uzun ufuklu kodlamada iki model arasında oldukça belirgin bir fark var (NL2Repo’da 47,2’ye karşı 35,5).

Bu da bizi sürümde öne çıkan bir örneğe getiriyor: Qwen 3.7 Max’in uzun ufuklu çekirdek optimizasyon çalışması. Bildirildiğine göre Qwen 3.7 Max yaklaşık 35 saat çalışmış, 1.158 araç çağrısı yapmış, 432 çekirdek değerlendirmesini tamamlamış ve bir Triton referans uygulamasına göre geometrik ortalama 10,0x hız artışı elde etmiştir. 

Bu önemlidir çünkü modeli yalnızca statik kıyas sorularında değil, yinelemeli araç tabanlı iyileştirme üzerinde değerlendirildiğini gösterir.

Kısacası, Qwen 3.7 Max, modelin akıl yürütmesi, araç kullanması, bağlamı koruması ve bir çıktıyı birden çok turda iyileştirmesi gereken iş akışları için tasarlandığından, bu demo için çok uygun bir seçimdir.

Qwen 3.7 Max ile Düşünmeyi Koru(yan) Bir Üretkenlik Aracısı Oluşturma

Bu projede üç pratik fikri göstereceğiz:

• Belirsiz bir kullanıcı isteği, yapılandırılmış çok adımlı bir iş akışına dönüştürülebilir.
• Araç çıktıları, tek bir uzun isteme yığılmak yerine akıl yürütme sürecine geri katılabilir.
• Model, nihai çıktıyı kullanıcıya vermeden önce düşünce zinciri istemi aracılığıyla kendi çıktısını yeniden okuyup iyileştirebilir.

Proje genel bakış

Bir giriş kutusu ve bir düğmesi olan basit bir uygulama oluşturacağız; kullanıcı şu türden belirsiz bir istek girer:

I need to prepare a competitive analysis of the top 3 vector databases
for a team presentation next week. I have no idea where to start.Altyapı:

Ardından aracı sabit bir beş turlu iş akışını çalıştırır:

User prompt
Turn 1: Plan the work
Parallel research for Pinecone, Weaviate, and Qdrant
Turn 2: Summarize research
Turn 3: Build comparison matrix
Turn 4: Write competitive_analysis.md
Turn 5: Self-review and patch the markdown file
Streamlit file previewAltyapı:

Arayüz her adımı bir ilerleme kartı olarak gösterir. İş akışı tamamlandıkça kartlar beklemeden tamamlandı durumuna geçer. Sonunda kullanıcı her aşamayı inceleyebilir: planlama, araştırma, sentez, taslak, öz-değerlendirme ve son dosya önizlemesi.

Bu yaklaşım, her şeyi tek bir sohbet yanıtının arkasına saklamak yerine aracının iş akışını görünür kılar.

Depo kasıtlı olarak küçük tutuldu. Ana parçalar şunlardır:

• thinking_agent.py: Model çağrıları, istemler, düşünme koruma, araştırma, yeniden denemeler, dosya yazma ve öz-değerlendirme gibi arka uç ajan mantığını içerir.

• agent.py: Sayfa düzeni, istem kutusu, ilerleme çubuğu, adım kartları, sonuç seçici, markdown önizleme ve indirme düğmesi dahil Streamlit arayüzünü içerir.

• requirements.txt: Demoda gereken çalışma zamanı bağımlılıklarını içerir

Arka uç, sabit bir beş turlu diziyi çalıştıran ve yapılandırılmış tur kayıtları döndüren bir ThinkingAgent sınıfı etrafında şekillenir. Arayüzün, model çağrılarının, yeniden denemelerin veya araştırma yayılımının nasıl çalıştığını bilmesi gerekmez. Sadece her tur geldiğinde onu görüntülemesi yeterlidir.

Bu eğitimin tüm kodu GitHub’da mevcuttur.

Not: Qwen 3.7 Max’e erişmek için OpenRouter kullandım; ancak modeli resmi Qwen API Platformu üzerinden de kullanabilirsiniz. 

Adım 1: Ortam kurulumu

Qwen 3.7 Max üretkenlik aracısını oluşturmadan önce, Streamlit, OpenAI uyumlu istemci ve hafif web araması için httpx ile küçük bir Python ortamı kurmamız gerekiyor.

Bu eğitimde model geçidi olarak OpenRouter’ı kullanacağız; ancak arka uç, OpenAI uyumlu API formatıyla yazılmıştır. Bu da aynı yapının daha sonra Alibaba Cloud Model Studio veya başka herhangi bir uyumlu sağlayıcı için uyarlanabileceği anlamına gelir.

Bu adımda şunları yapacağız:

• Sanal bir ortam oluşturma

• Gerekli bağımlılıkları yükleme

• OPENROUTER_API_KEY veya QWEN_API_KEY’i ayarlama

• Uygulamanın Streamlit ile başlatılabildiğini doğrulama

Bir sanal ortam oluşturup etkinleştirin:

python3 -m venv .venv
source .venv/bin/activateAltyapı:

Proje bağımlılıklarını yükleyin:

pip install -r requirements.txtAltyapı:

requirements.txt dosyası kasıtlı olarak küçüktür:

httpx>=0.23.0
openai>=1.30.0
streamlit>=1.45.0Altyapı:

streamlit etkileşimli web arayüzünü oluşturmak için, openai ise OpenAI uyumlu bir API üzerinden Qwen 3.7 Max’i çağırmak için; httpx de araştırma adımı için hafif canlı arama sonuçlarını almak üzere kullanılır.

Adım 2: Qwen 3.7 Max istemcisini yapılandırın

Arka uç, OpenRouter bir OpenAI uyumlu uç nokta sunduğu için OpenAI Python SDK’sını kullanır. thinking_agent.py dosyası birkaç varsayılan tanımlar:

from openai import OpenAI
DEFAULT_MODEL = "qwen/qwen3.7-max"
DEFAULT_BASE_URL = "https://openrouter.ai/api/v1"
DEFAULT_REFERER = "https://qwen.ai"
DEFAULT_TITLE = "Qwen3.7-Max Productivity Agent"Altyapı:

Ardından bir istemci oluştururuz:

def build_client(
   api_key: str | None = None,
   base_url: str | None = None,
   referer: str = DEFAULT_REFERER,
   title: str = DEFAULT_TITLE,
) -> OpenAI:
   return OpenAI(
       base_url=base_url or DEFAULT_BASE_URL,
       api_key=api_key,
       default_headers={
           "HTTP-Referer": referer,
           "X-Title": title,
       },
   )Altyapı:

build_client() işlevi, sağlayıcıya özgü tüm yapılandırmayı merkezileştirir. Uygulamanın geri kalanının isteğin OpenRouter, Alibaba Cloud Model Studio veya başka bir uyumlu uç noktadan geçip geçmediğini bilmesine gerek yoktur.

İstemci yapılandırıldıktan sonra, arka uç standart sohbet tamamlamaları formatını kullanarak Qwen 3.7 Max’i çağırabilir.

Şimdi temel ThinkingAgent iş akışını oluşturacağız.

Adım 3: Beş turlu agent iş akışı

Model istemcisi yapılandırıldığına göre, temel arka uç iş akışını tanımlayabiliriz. Qwen 3.7 Max’ten tek seferde tam bir rapor üretmesini istemek yerine, görevi beş kontrollü aşamaya böleriz.

• Planlama: Belirsiz istemi yapılandırılmış bir görev planına dönüştürür.

• Araştırma: Harici parçacıklardan kanıt toplar ve özetler.

• Sentez: Araştırmadan bir karşılaştırma matrisi oluşturur.

• Taslak: İlk competitive_analysis.md raporunu yazar.

• Öz-değerlendirme: Nihai dosyayı döndürmeden önce raporu gözden geçirip yamalar.

class ThinkingAgent:
   def run(
       self,
       goal: str,
       preserve_thinking: bool = True,
       data_mode: str = "live",
       on_turn: Callable[[TurnRecord], None] | None = None,
   ) -> ThinkingRunResult:
       history = [{"role": "system", "content": SYSTEM_PROMPT}]
       turns = []
       backend = self._build_search_backend(data_mode)
       turn1 = self._run_turn(
           history=history,
           turn_index=1,
           phase="planning",
           user_prompt=_planning_prompt(goal),
           preserve_thinking=preserve_thinking,
       )
       search_results = self._run_research(backend)
       turn2 = self._run_turn(
           history=history,
           turn_index=2,
           phase="research",
           user_prompt=_research_prompt(goal, search_results),
           preserve_thinking=preserve_thinking,
       )


       turn3 = self._run_turn(
           history=history,
           turn_index=3,
           phase="synthesis",
           user_prompt=_synthesis_prompt(),
           preserve_thinking=preserve_thinking,
       )
       turn4 = self._run_turn(
           history=history,
           turn_index=4,
           phase="draft",
           user_prompt=_draft_prompt(goal),
           preserve_thinking=preserve_thinking,
       )
       turn5 = self._run_turn(
           history=history,
           turn_index=5,
           phase="self_review",
           user_prompt=_self_review_prompt(draft_markdown),
           preserve_thinking=preserve_thinking,
       )Altyapı:

run() yöntemi ana orkestrasyon döngüsüdür. Bir sistem istemiyle başlar, bir konuşma geçmişi oluşturur, bir araştırma arka ucu kurar ve ardından beş turu teker teker yürütür.

Her _run_turn() çağrısının belirli bir aşaması vardır. Bu, iş akışını hata ayıklamayı kolaylaştırır çünkü her model çağrısının net bir sorumluluğu olur. Planlama turu planlar. Araştırma turu harici parçacıkları yorumlar. Sentez turu yapı kurar. Taslak turu yazar. Öz-değerlendirme turu çıktıyı iyileştirir.

Araştırma adımı, modelin harici bilgiyi iş akışına katmadan önce görevi anlaması gerektiği için 1. ve 2. tur arasına yerleştirilmiştir.

Bir sonraki adımda, modelin bu turlar arasında süreklilik sağlamasına yardımcı olan Qwen’e özgü düşünme koruma mantığını ekleyeceğiz.

Adım 4: Turlar arasında düşünmeyi koruyun

Bu demoda Qwen 3.7 Max kullanmamızın ana nedeni, düşünmeyi koruyan iş akışlarını desteklemesidir. Aracı, her model çağrısını bağımsız bir istem olarak ele almaz. Bunun yerine, önceki turlardan akıl yürütmeyi koruyabilir ve bu bağlamı sonraki turlara aktarabilir.

Bu adımda şunları yapacağız:

• Model düşünmesini etkinleştirin.
• Turlar arasında akıl yürütmeyi koruyun.
• Asistan çıktılarını ortak geçmişe geri ekleyin.

response = self.client.chat.completions.create(
   model=self.config.model,
   messages=request_messages,
   extra_body={
       "enable_thinking": True,
       "preserve_thinking": preserve_thinking,
   },
)Altyapı:

enable_thinking=True bayrağı, Qwen 3.7 Max’in yanıt sırasında akıl yürütme içeriği üretmesine izin verir. preserve_thinking bayrağı ise bu akıl yürütme içeriğinin sonraki turlarda korunup korunmayacağını kontrol eder.

Model yanıt verdikten sonra arka uç hem görünür yanıtı hem de akıl yürütme içeriğini çıkarır:

message = response.choices[0].message
assistant_content = _normalize_text(getattr(message, "content", ""))
reasoning_content = _extract_reasoning_content(message)
The visible answer is what the app can show to the user. The reasoning content is used internally to help the next turn stay aligned with the earlier plan.
Then the backend appends the assistant message back into the conversation history:
```python
assistant_message = {
   "role": "assistant",
   "content": assistant_content,
}
if preserve_thinking and reasoning_content:
   assistant_message["reasoning_content"] = reasoning_content
history.append(assistant_message)Altyapı:

Eğer planlama turu, nihai raporun dağıtım modeli, ölçeklenebilirlik, geliştirici deneyimi, hibrit arama ve kurumsal olgunluk açısından vektör veritabanlarını karşılaştırmasına karar verirse, sonraki turlar bu kriterleri kullanmaya devam edebilir. Bu olmadığında turlar sapabilir. Sentez adımı planlama adımından farklı kriterler seçebilir ya da öz-değerlendirme adımı raporu farklı bir hedefe göre değerlendirebilir.

Şimdi, raporu yazmadan önce aracıya harici bağlam sağlayan araştırma katmanını ekleyeceğiz.

Adım 5: Yedek verilerle paralel araştırma ekleyin

Model, bir rekabet analizi yazmadan önce bir miktar harici bağlama ihtiyaç duyar. Bu demoda, kapsamı sabit tutmak için üç vektör veritabanını karşılaştırıyoruz: Pinecone, Weaviate ve Qdrant.

Bu adımda şunları yapacağız:

• Hedef veritabanlarını tanımlayın.
• Araştırma çağrılarını paralel çalıştırın.
• Canlı arama başarısız olursa belirlenimci sabit veriye geri dönün.

DATABASES = ("Pinecone", "Weaviate", "Qdrant")Altyapı:

Hedef liste kasıtlı olarak sabit tutulur. Bu, demoyu istikrarlı ve açıklaması kolay kılar. Daha sonra, modeli karşılaştırma hedeflerini dinamik olarak seçebilecek şekilde projeyi genişletebilirsiniz.

Ardından arka uç, araştırma çağrılarını paralel başlatır:

from concurrent.futures import ThreadPoolExecutor, as_completed
with ThreadPoolExecutor(max_workers=3) as executor:
   future_map = {
       executor.submit(backend.search, database, query): database
       for database, query in queries.items()
   }
   for future in as_completed(future_map):
       database = future_map[future]
       results[database] = future.result()Altyapı:

ThreadPoolExecutor, her veritabanı için bir arama başlatır. Pinecone, Weaviate ve Qdrant araştırmaları paralel çalışabildiğinden, bu aramaları sıralı yürütmekten daha hızlıdır.

try:
   results[database] = future.result()
except Exception as exc:
   fallback = FixtureSearchBackend().search(database, queries[database])
   fallback.warning = (
       f"Live search failed for {database} ({exc}). "
       "Fallback demo research was used."
   )
   results[database] = fallbackAltyapı:

Canlı arama çalışırsa, aracı taze parçacıkları kullanır. Başarısız olursa, uygulama, yerleşik belirlenimci araştırma parçacıklarını kullanarak iş akışını yine de tamamlar. Buradaki önemli tasarım ilkesi zarif bozulmadır. Aracı, tek bir harici bağımlılık başarısız oldu diye çökmemelidir.

Bir sonraki adımda, bu araştırma sonuçlarını bir karşılaştırma matrisi sentezleyebilmesi için Qwen 3.7 Max’e aktaracağız.

Adım 6: Sentez ve karşılaştırma matrisi oluşturun

Aracı araştırma parçacıklarına sahip olduğunda, sıradaki iş sentezdir. Bu adım, dağınık bilgileri, nihai raporu destekleyebilecek yapılandırılmış bir karşılaştırmaya dönüştürür.

Bu adımda şunları yapacağız:

• Araştırma bağlamını Qwen 3.7 Max’e geri gönderin.
• Modelden yapılandırılmış bir karşılaştırma oluşturmasını isteyin.
• Daha sonra bu çıktıyı Streamlit arayüzünde görüntüleyin.

turn3 = self._run_turn(
   history=history,
   turn_index=3,
   phase="synthesis",
   user_prompt=_synthesis_prompt(),
   preserve_thinking=preserve_thinking,
)Altyapı:

Bu kod çalıştığında, konuşma geçmişi zaten orijinal kullanıcı isteğini, planlama çıktısını, araştırma özetlerini ve isteğe bağlı olarak önceki turlardan korunan akıl yürütmeyi içermektedir.

Bu, sentez isteminin tüm görevi yeniden ifade etmesine gerek olmadığı anlamına gelir. Tek bir işe, yani araştırmayı karar-verilebilir bir karşılaştırma matrisine dönüştürmeye odaklanabilir.

İyi bir sentez, seçenekleri şu boyutlar üzerinden karşılaştırmalıdır:

• Dağıtım modeli
• Ölçeklenebilirlik
• Geliştirici deneyimi
• Hibrit arama desteği
• Kurumsal olgunluk
• En uygun kullanım senaryosu

Ayrıca, ilk Markdown raporunu yazmak için bu sentezlenmiş yapıyı kullanacağız.

Adım 7: Markdown raporunu yazın

Planlama, araştırma ve sentezden sonra, aracı ilk tam teslimatı yazmak için yeterli bağlama sahiptir. Bu demoda teslimat, competitive_analysis.md adlı bir markdown dosyasıdır.

Bu adımda şunları yapacağız:

• Qwen 3.7 Max’ten ilk rapor taslağını yazmasını isteyin.
• Gereksiz markdown kod çitlerini kaldırın.
• Taslağı diske kaydedin.
• Dosya yazma eylemini bir araç olayı olarak kaydedin.

turn4 = self._run_turn(
   history=history,
   turn_index=4,
   phase="draft",
   user_prompt=_draft_prompt(goal),
   preserve_thinking=preserve_thinking,
)Altyapı:

Taslak turu, kullanıcının orijinal hedefi, plan, araştırma ve sentez matrisi dahil tüm önceki bağlamı kullanır.

Model yanıtı daha sonra temizlenir ve diske yazılır:

draft_markdown = _strip_markdown_fences(turn4.assistant_content)
report_path = run_output_dir / "competitive_analysis.md"
report_path.write_text(draft_markdown)Altyapı:

_strip_markdown_fences() yardımcı işlevi kullanışlıdır; çünkü modeller sıklıkla markdown çıktısını üçlü tırnak içine alır. Bu bir sohbet yanıtında sorun olmayabilir; ancak doğrudan bir .md dosyasına yazarken ideal değildir.

Arka uç ayrıca yazma eylemini kaydeder:

turn4.tool_events.append(
   ToolEvent(
       name="write_file",
       status="completed",
       input_payload={"path": str(report_path)},
       output_payload={
           "description": "Initial draft written to disk.",
       },
   )
)Altyapı:

Bu araç olayı, arka ucun sadece başka bir metin yanıtı değil, gerçek bir dosya oluşturduğunu arayüzün göstermesine yardımcı olur. Bu aşamada uygulamada zaten kullanılabilir bir rapor vardır. Ancak, son çıktıyı göstermeden önce kaliteyi artırmak için bir model turu daha ekliyoruz.

Bir sonraki adımda, Qwen 3.7 Max’ten kendi taslağını gözden geçirip yamamasını isteyeceğiz.

Adım 8: Öz-değerlendirme ve raporu yamalama

Son model turu öz-değerlendirme adımıdır. İlk taslağı kullanıcıya hemen vermek yerine, aracı raporu yeniden okur, orijinal hedefe göre kontrol eder ve iyileştirilmiş bir sürüm yazar.

Bu adımda şunları yapacağız:

• Taslak markdown’ı yeniden modele gönderin.
• Modelden zayıf noktaları belirlemesini isteyin.
• Gözden geçirilmiş bir sürüm üretin.
• Raporu geliştirilmiş nihai sürümle üzerine yazın.

turn5 = self._run_turn(
   history=history,
   turn_index=5,
   phase="self_review",
   user_prompt=_self_review_prompt(draft_markdown),
   preserve_thinking=preserve_thinking,
)Altyapı:

Öz-değerlendirme istemi, modelden pratik konuları kontrol etmesini ister; örneğin öneri net mi, karşılaştırma kriterleri tutarlı mı ve rapor bir ekip sunumu için yararlı mı gibi.

Gözden geçirilmiş çıktı aynı dosyaya geri yazılır:

final_markdown = _strip_markdown_fences(turn5.assistant_content)
report_path.write_text(final_markdown)Altyapı:

Aracı ayrıca son yazma olayını da kaydedebilir:

turn5.tool_events.append(
   ToolEvent(
       name="write_file",
       status="completed",
       input_payload={"path": str(report_path)},
       output_payload={
           "description": "Self-reviewed final report written to disk.",
       },
   )
)Altyapı:

Bu adım, uygulamayı basit bir üreticiden küçük bir editoryal iş akışına dönüştürür. Kullanıcının gördüğü çıktı ilk taslak değildir; gözden geçirilmiş ve yamalanmış sürümdür.

Şimdi, bu arka uç iş akışını Streamlit uygulamasına bağlayacağız.

Adım 9: Streamlit ilerleme arayüzünü oluşturun

Şimdi arka uç mantığından kullanıcı arayüzüne geçiyoruz. Streamlit uygulaması, kullanıcının bir istem girmesine, iş akışını çalıştırmasına ve her aşamanın tamamlandığını izlemesine izin vermelidir.

Not: Bu kod, kullanıcının ne gördüğünü ve tıkladığını kontrol ettiği için agent.py dosyasında yer almalıdır.

Bu adımda şunları yapacağız:

• Streamlit sayfasını yapılandırın.

• İstem girişini oluşturun.

• Bir çalıştır düğmesi ekleyin.

• ThinkingAgent.run() işlevini çağırın.

• Turlar tamamlandıkça arayüzü güncelleyin.

def render_streamlit_app() -> None:
   st.set_page_config(
       page_title="Qwen3.7-Max Demo Agent",
       page_icon=":material/psychology:",
       layout="wide",
       initial_sidebar_state="collapsed",
   )Altyapı:

Uygulama, adım kartları, ilerleme göstergeleri ve sonuç panellerini içerdiğinden geniş düzen kullanır.

Giriş alanı basittir:

goal = st.text_area(
   "Prompt",
   value=DEFAULT_GOAL,
   height=120,
   label_visibility="collapsed",
)

run_clicked = st.button("Run Demo", use_container_width=True)Altyapı:

Kullanıcının yalnızca görevi sağlaması gerekir. Uygulama, sıcaklık, arama modu, model kimliği veya akıl yürütme ayarlarını yapılandırmasını istemez. Bu ayrıntılar arka uç tarafından ele alınır.

Kullanıcı düğmeye tıkladığında, agent.py arka uç ajanını oluşturur ve çalıştırır:

agent = ThinkingAgent(config=config)

result = agent.run(
   goal=goal,
   preserve_thinking=True,
   data_mode="live",
   on_turn=on_turn,
)Altyapı:

İki dosyanın kesiştiği yer burasıdır. agent.py iş akışını tetikler; ancak gerçek ajan davranışı thinking_agent.py’nindir. Arayüz geri çağrısı her turdan sonra sayfayı günceller:

def on_turn(turn: TurnRecord) -> None:
   partial_turns.append(turn)

   progress_placeholder.progress(
       len(partial_turns) / len(phase_order),
       text=f"Completed {_phase_label(turn.phase)}",
   )

   with steps_placeholder.container():
       _render_step_cards(partial_turns, result_ready=False)Altyapı:

Geri çağrı tamamlanmış bir TurnRecord alır ve ilerleme çubuğunu ve adım kartlarını yeniler. Yürütme sırasında kartlar durum göstergesi olarak davranır. Tamamlandıktan sonra tıklanabilir sonuç görünümlerine dönüşürler.

Şimdi, son markdown raporunu görüntüleyip indirilebilir bir dosya olarak sunacağız.

Adım 10: Nihai raporu önizleyin ve indirin

Arka uç tamamlandıktan sonra, arayüzün nihai raporu görüntülemesi gerekir. Arka uç zaten markdown dosyasını oluşturdu; dolayısıyla agent.py’nin tek yapması gereken onu okumak, görüntülemek ve bir indirme düğmesi sunmaktır.

Bu adımda şunları yapacağız:

• Rapor dosyasının var olup olmadığını kontrol edin.
• Nihai markdown içeriğini okuyun.
• Bir indirme düğmesi gösterin.
• Markdown’ı Streamlit uygulamasında görüntüleyin

def _render_file_preview(report_path: str) -> None:
   path = Path(report_path)

   if not path.exists():
       st.info("No file was written yet.")
       return
   content = path.read_text()
   st.caption(f"Created file: {path.name}")
   st.download_button(
       "Download competitive_analysis.md",
       data=content,
       file_name=path.name,
       use_container_width=True,
   )
   st.markdown(content)Altyapı:

İşlev, dosyanın var olup olmadığını kontrol ederek başlar. Bu, arka uç raporu yazmadan önce başarısız olduysa uygulamanın çökmesini önler. Ardından markdown içeriğini okur ve bir indirme düğmesi oluşturur. Son olarak, markdown’ı doğrudan Streamlit sayfasında görüntüler.

Bu, sorumlulukların net bir ayrımıdır; burada:

• thinking_agent.py raporu yazar

• agent.py raporu önizler ve indirir

Bir sonraki adımda, sağlayıcı rotaları başarısız olduğunda veya hız sınırlarıyla karşılaşıldığında demonun daha iyi davranması için temel hata işleme ekleyeceğiz.

Adım 11: Hata ve hız sınırı yönetimi

Model sağlayıcıları zaman aşımına uğrayabilir, geçici hatalar döndürebilir veya istekleri hızla sınırlayabilir. Bu ham hataları doğrudan kullanıcılara gösterirsek, uygulama bitmemiş hissi verir.

Bu adım her iki dosyaya da dağılmıştır. Yeniden deneme mantığı, arka uç model çağrısının parçası olduğu için thinking_agent.py’ye aittir. Hata mesajı ise kullanıcının ne gördüğünü kontrol ettiği için agent.py’ye aittir.

Bu adımda şunları yapacağız:

• Arka uçta geçici sağlayıcı hatalarını yeniden deneyin.
• Hız sınırı benzeri hataları tespit edin.
• Streamlit arayüzünde daha temiz bir mesaj gösterin

delays = (1.0, 2.0)

for attempt_index in range(len(delays) + 1):
   try:
       return self.client.chat.completions.create(...)
   except Exception as exc:
       if not _is_retryable_provider_error(exc):
           raise

       if attempt_index >= len(delays):
           raise

       time.sleep(delays[attempt_index])Altyapı:

Arka uç model çağrısını dener, yeniden denenebilir hataları yakalar, kısa bir süre bekler ve tekrar dener. Kısa gecikmeler, kullanıcıyı fazla bekletmeden geçici sağlayıcı dengesizliklerini yumuşatmak için yeterlidir.

def _friendly_rate_limit_message(exc: Any) -> str:
   return (
       "Qwen 3.7 Max is temporarily rate-limited upstream. "
       "Please wait 30 to 60 seconds and try again."
   )Altyapı:

Bu, ham sağlayıcı JSON’larını veya yığın izlerini arayüzün dışında tutar. Kullanıcı net bir açıklama ve pratik bir sonraki adım alır.

Bu son adımla, artık tam uygulamayı çalıştırabilir ve uçtan uca iş akışını test edebiliriz.

Adım 12: Demoyu çalıştırın

Arka uç iş akışı ve Streamlit arayüzü bağlandığına göre, tam uygulamayı çalıştırabiliriz.

Bu adımda şunları yapacağız:

• Streamlit uygulamasını başlatın.
• Varsayılan üretkenlik istemini girin.
• Beş aşamalı iş akışını çalıştırın.
• Nihai markdown raporunu önizleyin ve indirin

Uygulamayı başlatın:

streamlit run agent.pyAltyapı:

Varsayılan istemi kullanın:

I need to prepare a competitive analysis of the top 3 vector databases
for a team presentation next week. I have no idea where to start.Altyapı:

Run Demo’ya tıkladığınızda uygulama tam iş akışından geçer:

• Planlama: Yapılandırılmış bir plan oluşturur.

• Araştırma: Pinecone, Weaviate ve Qdrant için parçacıklar toplar.

• Sentez: Bir karşılaştırma matrisi oluşturur.

• Taslak: İlk markdown raporunu yazar.

• Öz-değerlendirme: Raporu yamar.

• Önizleme: Son competitive_analysis.md dosyasını gösterir.

Nihai rapor şu dizin altında kaydedilir:

output/showcase_runs/<timestamp>/with_preserve/competitive_analysis.md

Sonunda, Streamlit arayüzünde rapor önizlemesini ve bir indirme düğmesini görmelisiniz.

Sonuç

Bu eğitimde, planlamadan araştırmaya, sentezden yazmaya ve öz-değerlendirmeye kadar sabit, yorumlanabilir bir iş akışı çalıştıran Qwen 3.7 Max ile derli toplu bir üretkenlik aracısı oluşturduk. Bu süreçte, turlar arasında akıl yürütmeyi korumanın uzun biçimli agent görevleri için neden faydalı olabileceğini gösterdik.

Mevcut sürüm yalnızca Streamlit, OpenAI uyumlu model çağrıları, hafif bir arama katmanı ve Markdown çıktısı kullanır. Bu da onu kendi deneylerinizde incelemeyi, değiştirmeyi ve yeniden kullanmayı kolaylaştırır.

Buradan yapılabilecek pek çok doğal genişletme vardır:

• Modelin sabit bir liste yerine karşılaştırma hedeflerini seçmesine izin verin

• preserve_thinking ile “var” ve “yok” çalıştırmalarını yan yana ekleyin

• Arayüzde token kullanımı ve maliyet tahminlerini gösterin

• Markdown raporunun yanında bir slayt taslağı veya grafik üretin

• DuckDuckGo kazımayı daha sağlam bir arama API’siyle değiştirin

Eğer sabit bir iş akışının ötesine geçmek ve üretim düzeyinde yapay zekâ uygulamalarını, istem mühendisliğinden RAG’a ve agentik sistemlere kadar nasıl oluşturacağınızı öğrenmek istiyorsanız, LangChain ile Yapay Zekâ Mühendisliği beceri yolumuz iyi bir sonraki adımdır.