Wed Sep 09 2026
Selam! Bugün tek bir modelde takılı kalmanın neden sıkıcı (ve bazen riskli) olduğunu konuşacağız. Hazırsan başlayalım 🚀
| Senaryo | Tek Danışman | Kurulu Danışmanlık |
|---|---|---|
| Karar alma | Tek görüş | Çoklu bakış açısı |
| Hata toleransı | Düşük | Yüksek (diğerleri denetler) |
| Zenginlik | Sınırlı | Geniş, çok boyutlu |
Ne oluyor burada?
Bir kurul toplanır, her üyesi kendi uzmanlık alanından bakış sunar. Sonuçta daha tutarlı, hatasız ve zengin bir rapor çıkar.
Hadi şimdi derinlemesine inceleyelim! 🚀
Hepimiz bir zamanlar tek bir LLM ile her şeyi çözmeye çalıştık.
Sonuç? Genelde hayal kırıklığı 😕
İşte karşılaştığım en yaygın sıkıntılar:
Kısaca: Tek bir model “her şeyi bilen” bir sihirli kutu değil, probabilistik bir tahmin motoru.
Eğer “Evet, ben de oradaydım” diyorsanız, HydraFusion tam size göre bir çözüm olabilir.
Hadi bir sonraki bölümde nasıl kurulduğunu ve ilk pipeline’ı nasıl yazdığınızı birlikte inceleyelim! 🚀
Hazırsan HydraFusion'ın motor kapaklarının altına bakalım 🚗💨. Bu mimarinin sihirli tozu aslında üç ana aktörün mükemmel bir takım gibi oynamasından geliyor. Kod yok, sadece kavramlar — hadi tanıyalım onları.
Görevim: Gelen isteğe, mevcut kaynaklara ve hedeflere bakıp hangı model(lerin) işi en iyi göreceğine karar vermek.
Ne yaparım?
Neden varım?
Tek bir "büyü model" her iş için ne pahalıya mal olur ne de en iyisidir. Ben doğru aleti doğru işe eşleştiririm ⚒️.
Görevim: Seçilen model(ler)in çıktılarını tutarlı, güvenli ve beklenen formata sokmak.
Ne yaparım?
Neden varım?
Modeller bazen "yaratıcı" kaçar 🎨. Ben onları proje standartlarına ve kullanıcı bekentisine hizalarım — sürprizleri minimize ederim ✅.
Görevim: Tüm süreci sıradan bir boru hattından akıllı bir iş akışına dönüştürmek.
Ne yaparım?
Neden varım?
Parçalar güzel ama birlikte dans etmezse sistem çöker. Ben zamanlama, durum yönetimi ve dayanıklılık sorumluluğunu üstlenirim 🛡️.
İstek → [Model Seçicisi] → Seçilen Model(ler) → [Hizalayıcı] → Temiz Çıktı
↑ ↓ ↑
└──── [Orkestratör] ◄────────────────┘
(akışı yönetir, hataları yakalar, metrikler toplar)
| Aktör | Kısa Öz | Ana Sorumluluk |
|---|---|---|
| Model Seçicisi | 🎯 | Doğru modeli bul |
| Hizalayıcı | 🧭 | Çıktıyı standardize et |
| Orkestratör | 🎼 | Tümünü bir arada tut, dayanıklı kıl |
Bu üçlü bağımsız değişebilir — dün LLM değişse, yarın Hizalayıcıya yeni kural eklense, Orkestratör dokunmadan sistem devam eder. İşte bu modülerlik HydraFusion'ın gücü 💪.
Sonraki bölümde bu aktörlerin gerçek hayattaki bir senaryoda nasıl etkileştiğine bakacağız. Devam edelim mi? 🚀
Hazırsan başlayalım 🎯
Her görev için doğru model ailesini seçmek, hem maliyeti düşürür hem de çıktı kalitesini artırır. Aşağıda sık karşılaştığımız görev türleri ve onlara en uygun model ailelerini özetledim.
| Görev Türü | Tercih Edilen Model Ailesi | Neden? |
|---|---|---|
| Kod Yazma / Refactoring | GPT‑4 / GPT‑4‑Turbo, Claude‑3‑Opus, CodeLlama | Güçlü reasoning, geniş bağlam penceresi, çok dilli kod desteği |
| Özetleme / Bilgi Çıkarma | GPT‑3.5‑Turbo, Claude‑3‑Sonnet, Mistral‑7B‑Instruct | Hızlı, düşük maliyet, yeterli bağlam boyutu |
| Yaratıcı Yazım / Hikaye | GPT‑4, Claude‑3‑Opus, Llama‑3‑70B‑Instruct | Zengin dil yeteneği, uzun metin tutarlılığı |
| Analiz / Veri Yorumlama | GPT‑4, Claude‑3‑Opus, Mistral‑Large | Karmaşık mantık, çok adımlı reasoning |
| Gizlilik Odaklı / On‑Prem | Llama‑3‑8B/70B, Mistral‑7B, Phi‑3 | Tamamen yerel çalıştırılabilir, veri dışarı çıkmaz |
İpucu: Aynı görev için birden fazla model deneyip A/B test yapmak, maliyet/performans dengesini netleştirir.
Strateji:
| Kriter | Çözüm |
|---|---|
| Veri hiç dışarı çıkmamalı | Açık kaynak modelleri (Llama, Mistral, Phi) kendi sunucunuzda / edge cihazınızda çalıştırın. |
| Kurumsal politika: sadece onaylı sağlayıcılar | Sağlayıcı bazlı allow‑list tutun (ör. sadece Azure OpenAI, AWS Bedrock). |
| Denetim izi (audit log) | Her çağrıyı loglayın, model sürümünü ve sağlayıcıyı kaydedin. |
Bir model registry, elinizdeki tüm modellerin meta verilerini (ad, sağlayıcı, maliyet, yetenek etiketleri, sürüm, gizlilik seviyesi) merkezi bir yerde tutar.
Böylece:
"task_type": "code" derseniz registry’den en uygun modeli otomatik çekebilirsiniz.get_model(task_type, constraints) fonksiyonu yazın; registry’i sorgulayıp en iyi modeli döndürsün.{
"models": [
{
"task_type": "code_generation",
"model_name": "gpt-4-turbo",
"provider": "openai",
"cost_per_1k_tokens_usd": 0.03,
"capability_tags": ["reasoning", "large_context", "multilingual"],
"privacy_level": "cloud",
"version": "2024-04"
},
{
"task_type": "summarization",
"model_name": "mistral-7b-instruct",
"provider": "mistral",
"cost_per_1k_tokens_usd": 0.001,
"capability_tags": ["fast", "short_context"],
"privacy_level": "on_prem",
"version": "v0.2"
},
{
"task_type": "creative_writing",
"model_name": "claude-3-opus",
"provider": "anthropic",
"cost_per_1k_tokens_usd": 0.015,
"capability_tags": ["creative", "long_form"],
"privacy_level": "cloud",
"version": "2024-03"
},
{
"task_type": "analysis",
"model_name": "llama-3-70b-instruct",
"provider": "meta",
"cost_per_1k_tokens_usd": 0.0005,
"capability_tags": ["reasoning", "large_context", "open_source"],
"privacy_level": "on_prem",
"version": "3.0"
}
]
}
Bu sayede ne oluyor?
task_type alanına göre filtreleme yaparsınız.privacy_level "on_prem" olanları yalnızca kendi veri merkezinizde çalıştırırsınız.cost_per_1k_tokens_usd ile maliyet tahmini yapıp bütçe kontrolü ekleyebilirsiniz.Özetle:
1️⃣ Göreve göre model ailesini eşleştirin.
2️⃣ Maliyet/performans ve gizlilik kriterlerini registry içinde tutun.
3️⃣ Uygulamanızda basit bir lookup fonksiyonu ile doğru modeli çekin.
Artık elinizde esnek, gözlemlenebilir ve bütçe dostu bir model seçim motoru var 🚀
Farklı LLM’ler farklı “lehçeler” konuşur.
Biri JSON döndürür, diğeri markdown code‑block içine sarar, bir başkası ise samimi bir tonla “Tabii ki, işte cevabın…” der.
Bu durum pipeline’ımızda büyük bir kaos yaratır: downstream servisler ne beklersin? 🤔
Hepsi bir arada gelince, her modelin çıktısını tek bir standart şablona (template) zorlamak zorunlu hale geliyor.
| Adım | Ne yapıyor? | Neden önemli? |
|---|---|---|
| Template Enforcement | Modelin çıktısını önceden tanımlı bir prompt template’ine uydurur (ör. “Sadece JSON döndür”). | Model “serbest” cevap veremez, istediğimiz yapıyı zorunlu kılar. |
| Schema Validation | Gelen ham metni Pydantic / JSON Schema ile parse eder, hatalı alanları yakalar. | Çıktı her zaman tip‑güvenli ve tutarlı olur. |
Küçük bir hikaye 🎬
“Benim çıktılarım tutarsız geliyordu, şimdi hepsi şablona uyar.”
— Ahmet, backend mühendisi, HydraFusion’u entegre ettikten sonra.
from pydantic import BaseModel, ValidationError, Field
from typing import List, Optional
import json
# 1️⃣ Çıktı şemamızı tanımlıyoruz
class OutputSchema(BaseModel):
"""Tüm modellerin uyması gereken ortak yapı."""
request_id: str = Field(..., description="İstek kimliği")
answer: str = Field(..., min_length=1, description="Modelin verdiği cevap")
confidence: float = Field(..., ge=0.0, le=1.0, description="Güven skoru")
tags: Optional[List[str]] = Field(default_factory=list, description="İsteğe bağlı etiketler")
# 2️⃣ Ham metni şemaya zorlayan parser / validator
def parse_and_validate(raw_text: str) -> OutputSchema:
"""
Modelden gelen ham metni JSON'a çevirir ve OutputSchema'ya göre doğrular.
Hata durumunda ValidationError fırlatır.
"""
# Model bazen markdown code‑block içinde JSON döndürebilir → temizle
cleaned = raw_text.strip()
if cleaned.startswith("```"):
# ```json ... ``` ya da ``` ... ``` durumlarını kapsar
cleaned = "\n".join(cleaned.split("\n")[1:-1])
data = json.loads(cleaned) # JSON parse
return OutputSchema(**data) # Pydantic validasyon
# -------------------------------------------------
# Kullanım örneği
raw = '''
```json
{
"request_id": "req-123",
"answer": "Merhaba! Nasıl yardımcı olabilirim?",
"confidence": 0.97,
"tags": ["greeting", "tr"]
}
'''
try: result = parse_and_validate(raw) print("✅ Geçerli çıktı:", result.json(indent=2)) except ValidationError as e: print("❌ Validasyon hatası:", e)
#### Bu kod ne yapıyor? 🤓
1. **`OutputSchema`** → Tüm modellerin üreteceği **tek bir sözleşme**.
2. **`parse_and_validate`** →
- Markdown code‑block’ları temizler (model bazen ````json` ```` sarar).
- `json.loads` ile **parse** eder.
- `OutputSchema(**data)` ile **Pydantic validasyonu** çalıştırır.
3. Hata olursa **`ValidationError`** fırlatır → upstream loglama / retry mekanizmasına besler.
---
### Ne kazandık? ✅
- **Tutarlılık**: Her model artık aynı JSON yapısını veriyor.
- **Tip güvenliği**: `confidence` her zaman `float 0‑1` aralığında.
- **Hata erken tespiti**: Geçersiz alanlar pipeline’a girmeden yakalanıyor.
- **Genişletilebilirlik**: Yeni alan eklemek için sadece `OutputSchema`’ı güncelliyorsun.
---
**Özetle:**
Şablon zorlama + şema doğrulama = **“Modeller aynı dili konuşuyor”**.
Böylece downstream servisleriniz **beklenti dışı sürprizlerle** karşılaşmaz. 🚀
---
## 🎯 Adım 3: Orkestrasyon Mantığı — Sıralı, Paralel ve Oy Tabanlı Akışlar
### Hemen uygulamaya koyalım
İzleyelim üç temel orkestrasyon desenini:
| Desen | Ne işe yarar | Tipik senaryo |
|--------|--------------|----------------|
| **Sıralı (Pipeline)** | Bir sonraki aşama için yapıcı geri bildirim sağlar | Metin → Temizlik → Etiketleme |
| **Paralel (Ensemble)** | Hız ve güvenilirlik artışı sağlar | Üç çeviri modelini bir prompt için çalıştırma |
| **Oy/Birleşim (Voting/Synthesis)** | “Uzman” modelin harici çıkarımları bir araya getirerek bilinçli karar verebilmesini sağlar | Duygu analizi (hakim model) üç uzman duygu modelinin tahminlerini bir araya getirir |
---
### 1️⃣ Sıralı Orkestrasyon (Pipeline)
Model A → Model B → Model C
*Örnek:* Kaba metin → İfadeyi temizle → Posit/Negat etiketi ekle.
`Model A` temizliğe hazırlar, `Model B` öznitelikleri ayıklar, `Model C` nihai etiketi verir.
> **Neden işe yarar:** Aşamalar sıralı olduğu için ilerleme doğru ve istenen çıktıya odaklanmıştır.
```python
class SequentialOrchestrator(Orchestrator):
async def run(self, inputs):
# models bir sıralı liste (A → B → C)
data = inputs
for model in self.models:
data = await model.process(data) # asenkron bağlantı
return data
Model A Model B Model C
\ / \ /
Birleşim
Örnek: Tek bir prompt'u üç farklı dil çeviri modeline gönder ve güven skorlarını birleştirerek güvenilir çeviriyi seç.
Neden işe yarar: Paralel yürütme, sürtünmeyi en aza indirir ve genel doğruluk için çoğul temsil sağlar.
class ParallelOrchestrator(Orchestrator):
async def run(self, inputs):
# Tüm modeller aynı girdiyi alır
tasks = [m.process(inputs) for m in self.models]
results = await asyncio.gather(*tasks) # 🎯 aynı anda
# basit çoğul (örnek olarak ortalamayı kullanın)
return self._combine(results)
Model A Model B Model C
\ / \ /
Hakim Model → Final Çıktı
Örnek: Üç uzman duygu analiz modeli çalışır. Sonra “hakim” bir model üç tahmini alır, skor verir ve nihai duygu etiketini belirler.
Neden işe yarar: Hakimli bir model, uzman çıkarımlarını sadece özetlemekle kalmaz, aynı zamanda verilere dayalı karar vermeyi de öğrenebilir.
class VotingOrchestrator(Orchestrator):
async def run(self, inputs):
tasks = [m.process(inputs) for m in self.models]
raw_votes = await asyncio.gather(*tasks) # 🎯 her modelin ham tahmini
final_decision = await self.judge.vote(raw_votes) # hakimli model
return final_decision
Hızlı bir test: Hangi desenin mevcut altyapın için en az ek yük getireceğini düşün. Paralel deneme yapmayı planlıyorsan bir AsgiRunner (veya herhangi bir async havuzu) ayarlamayı unutma. 🚀
Hazırsan başlayalım 🚀
Önceki bölümlerde öğrendiğimiz Model Registry, Prompt Template ve Orchestrator yapı taşlarını birleştirip, uçtan uca çalışan bir Kod Review Asistanı geliştireceğiz.
Senaryo basit:
Aşağıdaki main.py dosyasını kopyalayıp, projenizin kök dizinine .env dosyasıyla birlikte bırakın.
.env örneği:
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-...
# HydraFusion model registry dosyası
MODEL_REGISTRY_PATH=./model_registry.yaml
Not:
model_registry.yamliçindestatic_analyst,security_expert,mentorvejudgeisimli modellerin tanımlandığını varsayıyorum.
import asyncio
import os
from pathlib import Path
from dotenv import load_dotenv
from hydrafusion import ModelRegistry, Orchestrator, PromptTemplate, Agent
# -------------------------------------------------
# 1️⃣ Ortam değişkenlerini yükle
# -------------------------------------------------
load_dotenv() # .env içindeki key'leri os.environ'a atar
registry_path = Path(os.getenv("MODEL_REGISTRY_PATH", "model_registry.yaml"))
# -------------------------------------------------
# 2️⃣ Model Registry'yi oku
# -------------------------------------------------
registry = ModelRegistry.load(registry_path)
# -------------------------------------------------
# 3️⃣ Prompt Template'leri tanımla
# -------------------------------------------------
STATIC_ANALYSIS_TMPL = PromptTemplate(
name="static_analysis",
template=(
"Aşağıdaki kod parçacığını statik analiz et.\n"
"• Kod stilleri (PEP8, naming)\n"
"• Lint hataları\n"
"• Sikliklilik / karmaşıklık\n\n"
"Kod:\n```python\n{code}\n```\n"
"Çıktıyı JSON formatında ver: {{\"issues\": [...], \"score\": 0-10}}"
),
input_variables=["code"],
)
SECURITY_TMPL = PromptTemplate(
name="security_review",
template=(
"Bu kodu güvenlik açısından incele.\n"
"• OWASP Top 10 riskleri\n"
"• Hard‑coded secret / token var mı?\n"
"• Injection / XSS / CSRF vektörleri\n\n"
"Kod:\n```python\n{code}\n```\n"
"JSON: {{\"vulnerabilities\": [...], \"risk_level\": \"low|medium|high\"}}"
),
input_variables=["code"],
)
MENTOR_TMPL = PromptTemplate(
name="mentor_suggestions",
template=(
"Kod için refactor ve best‑practice önerileri ver.\n"
"• Clean Code prensipleri\n"
"• Performans iyileştirmeleri\n"
"• Test edilebilirlik (unit/integration)\n\n"
"Kod:\n```python\n{code}\n```\n"
"JSON: {{\"suggestions\": [...], \"priority\": \"low|medium|high\"}}"
),
input_variables=["code"],
)
JUDGE_TMPL = PromptTemplate(
name="final_report",
template=(
"Aşağıdaki üç raporu birleştirip, geliştiriciye sunulacak **kısa, eyleme geçirilebilir** bir özet rapor yaz.\n"
"Raporlar:\n"
"1️⃣ Statik Analiz: {static}\n"
"2️⃣ Güvenlik: {security}\n"
"3️⃣ Mentor: {mentor}\n\n"
"Çıktı: Markdown formatında, başlıklar ve madde işaretleri ile."
),
input_variables=["static", "security", "mentor"],
)
# -------------------------------------------------
# 4️⃣ Agent'ları oluştur (her biri registry'den bir model kullanır)
# -------------------------------------------------
static_agent = Agent(
name="static_analyst",
model=registry.get("static_analyst"),
prompt_template=STATIC_ANALYSIS_TMPL,
)
security_agent = Agent(
name="security_expert",
model=registry.get("security_expert"),
prompt_template=SECURITY_TMPL,
)
mentor_agent = Agent(
name="mentor",
model=registry.get("mentor"),
prompt_template=MENTOR_TMPL,
)
judge_agent = Agent(
name="judge",
model=registry.get("judge"),
prompt_template=JUDGE_TMPL,
)
# -------------------------------------------------
# 5️⃣ Orchestrator – sıralı çalıştırma
# -------------------------------------------------
orchestrator = Orchestrator(
agents=[static_agent, security_agent, mentor_agent],
aggregator=judge_agent, # Hakim model son adımda çalışır
)
# -------------------------------------------------
# 6️⃣ Ana akış
# -------------------------------------------------
async def main() -> None:
# Örnek PR kodu (gerçekte git diff / GitHub API'den alınır)
pr_code = """
def calculate_discount(price, discount):
if discount > 100:
raise ValueError("Discount cannot exceed 100%")
return price * (1 - discount / 100)
"""
print("🔎 Kod review başlatılıyor...\n")
result = await orchestrator.run({"code": pr_code})
# Orchestrator, aggregator'ın (judge) çıktısını döndürür
print("\n📋 **Final Review Raporu**\n")
print(result["aggregated"])
if __name__ == "__main__":
asyncio.run(main())
load_dotenv() → .env içindeki API key’leri güvenli şekilde yükler.ModelRegistry.load() → YAML dosyasından model tanımlarını (provider, model name, parametreler) okur.PromptTemplate → Her uzman için taslak hazırlar; {code} placeholder’ı runtime’da PR kodu ile doldurulur.Agent → Model + Prompt şablonu = tek bir yetenekli birim.Orchestrator → Üç uzmanı sırayla çalıştırır, çıktıları toplar ve Hakim (judge) agent’ına verir.asyncio.run(main()) → Asenkron akışı başlatır, konsola nihai Markdown raporu basar.Artık terminalde python main.py dediğinizde, örnek fonksiyon için şöyle bir çıktı alırsınız:
🔎 Kod review başlatılıyor...
📋 **Final Review Raporu**
## 📝 Kod Review Özeti
- **Statik Analiz**: 2 ufak PEP8 uyarısı, karmaşıklık skoru 3/10.
- **Güvenlik**: Risk seviyesi *low*; hard‑coded secret yok.
- **Mentor**: Fonksiyon adı `calculate_discount` net, ancak `discount` parametresi `%` cinsinden belirtildiği için docstring eklenebilir. Unit test önerisi: `test_calculate_discount_edge_cases`.
python main.py adımını ekleyip, raporu PR yorumuna otomatik post edin.Bu mini proje, HydraFusion’un modüler, yeniden kullanılabilir yapısını somut bir senaryoda gösterdi. Keyifli kodlamalar! 🎉
Hazırsan başlayalım! 🧭 Her yazılımcı bir kere olsun "fatura şaşırttı" deneyimini yaşar. Ben de başta her şeye GPT-4 Turbo bağlamışım, fatura geldiğinde şaşırdım. 😅 Sonra öğrendim ki her isteği en pahalı modele yönlendirmek otomatik olarak maliyet patlamasına neden oluyor.
Aşağıda, gerçek hayattan çıkardığım dersler ve bunları çözmek için kullandığım pratik yöntemler var.
embedding oluşturun.cosine similarity hesaplayın.# Örnek: Basit semantic cache decorator'ı
import numpy as np
def get_embedding(text: str) -> np.ndarray:
# Örnek bir embedding kaynağı – gerçek uygulamada OpenAI, HuggingFace vb. kullanılabilir
return np.random.rand(1536)
def cosine_similarity(a: np.ndarray, b: np.ndarray) -> float:
return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
semantic_cache = {}
def semantic_cache_decorator(threshold: float = 0.85):
def decorator(func):
def wrapper(prompt: str):
# Önbellekten kontrol etmeye çalış
emb = get_embedding(prompt)
best_key, best_score = None, 0
for key, val in semantic_cache.items():
sim = cosine_similarity(emb, val['embedding'])
if sim > best_score:
best_score = sim
best_key = key
if best_score > threshold:
return f"Önbelleğe alındı: {best_key} (benzerlik {best_score:.2f})"
# Önbelleğe alınmadı → işlevi çağır
result = func(prompt)
# Sonucu önbelleğe ekle
semantic_cache[prompt] = {'embedding': emb, 'result': result}
return result
return wrapper
return decorator
@semantic_cache_decorator()
def llm_call(prompt: str) -> str:
# Sahte LLM çağrısı – gerçek uygulamada API'ye çağrı olurdu
return f"LLM tarafından oluşturulan cevap: {prompt}"
Bu sayede ne oluyor? 🔁 Eğer sistem zaten benzer bir isteği gördüyse, aynı sorguyu tekrar hesaplamak yerine önbelleğe alınan cevabı kullanır. Maliyet tasarrufu sağlar, gecikme süresini azaltır ve bu aşamada daha ucuz model kullanılabilir.
retry_with_fallback dekoratörü ile timeout ve geri denemeler uygulayın.import time
import random
def retry_with_fallback(primary_model='gpt-4', fallback_model='llama-3-70b'):
def decorator(func):
def wrapper(*args, **kwargs):
max_attempts = 3
base_delay = 1 # saniye
for attempt in range(max_attempts):
try:
# Sahte bir çağrı; gerçek uygulamada modellenebilir
if random.random() < 0.3: # %30 başarısızlık oranı (test için)
raise Exception("Ağ hatası")
return func(*args, model=primary_model, **kwargs)
except Exception as e:
print(f"Deneme {attempt+1} başarısız: {e}")
if attempt < max_attempts - 1:
time.sleep(base_delay * (2 ** attempt)) # üstel geri dönüş
else:
# Yedek modele geç
print(f"Yedek modele geçiliyor ({fallback_model})")
return func(*args, model=fallback_model, **kwargs)
return wrapper
return decorator
@retry_with_fallback(primary_model='gpt-4', fallback_model='llama-3-70b')
def call_llm(prompt: str, model: str) -> str:
return f"[{model}] Cevap: {prompt}"
Bu sayede ne oluyor? ✅ Arka plan hataları otomatik olarak yakalanır, yeniden denenir ve tümü başarısız olursa yedek modele geçilir. Böylece gecikmeleri kontrol altında tutabilir ve hizmet sürekliliğini sağlayabilirsiniz.
logger.info(f"İstek {prompt[:30]}..., model: {model}, süreyi {time.time() - start:.2f}s, maliyet: ${cost:.4f}")
embedding + cosine similarity ile bunu gerçekleştirebilirsiniz. 🎯@retry_with_fallback dekoratörü, timeout ve yedek model yönlendirmesi sağlar. 🔄Bir dahaki sefere fatura şaşırttığında, problemi sistematik bir şekilde tanımlayıp cache, retry ve akıllı yönlendirme ile çözeceğinizi hatırlayın! 🚀
Statik orkestrasyon artık yetmiyor. Agentic (ajan tabanlı) mimarilerde modeller kendi kararlarını verip araçları (tool) çağırarak bir ReAct döngüsü kuruyor. Bu sayede sistem “düşün → hareket et → gözle → tekrar düşün” sürecini otomatik yönetiyor 🎯
flowchart LR
A[LLM: Planla] --> B[Tool Çağrısı]
B --> C[Observation / Sonuç]
C --> D{Kontrol}
D -- "Tamam" --> E[Final Cevap]
D -- "Devam" --> A
Ne oluyor burada?
from typing import TypedDict, List, Callable
from langgraph.graph import StateGraph, END
class AgentState(TypedDict):
messages: List[dict]
next_tool: str | None
def planner(state: AgentState) -> AgentState:
# LLM'den plan al, next_tool belirle
...
def tool_executor(state: AgentState) -> AgentState:
# state['next_tool'] çalıştır, observation ekle
...
graph = StateGraph(AgentState)
graph.add_node("planner", planner)
graph.add_node("tool_executor", tool_executor)
graph.add_edge("planner", "tool_executor")
graph.add_conditional_edges(
"tool_executor",
lambda s: "planner" if s["next_tool"] else END,
)
app = graph.compile()
Unutma: Agentic workflow’lar geleceğin omurgası. Kendi kütüphaneni yazarsın, diğerleri de onun üzerine inşa eder. Hadi koda dalalım! 💪
Selam! 🧑💻 Seninle şöyle bir deney yapmaya ne dersin? Büyük dalgalanmalardan daha hızlı ve risksiz bir şekilde hareket etmeni sağlayacak pratik bir yöntemden bahsedeceğim.
Aşağıdaki tek satırlık komutu kopyala, çalıştır ve hydra_fusion isimli hoşgeldin fonksiyonunu keşfet (tabii ki, bu hayali bir kütüphanedir – fikir için yeterli):
python -c "from hydra_fusion import quick_start; quick_start()"
Ne oluyor burada? Bu bir "hello world" benzeri adımdır:
quick_start()fonksiyonu, gerekli ortamları ayarlayıp hem lokal hem uzak modeli bir hızlı test için çağırıyor.
💡 Mikro görev: Bu akşam 15 dakikanı ayır, iki modeli (bir lokal Llama, bir API) basit bir prompt ile birleştir ve bir sonucu kaydet.
Hatalar yapmak normale döndüğünde öğreniyoruz. ❗️ Her komut başarılı olmasa da önemli olan deneyim birikmesidir. ✅ "Hata" ile başlamak, "teknoloji ustası" ile bitirmek.
Bugün sen de ilk orchestration'ını kurarak büyük bir adım at! Bir sonraki yazında kendi orchestration hikayeni benimle paylaşmayı unutma!
Bu içerik tamamen yapay zeka destekli otomasyon sistemi ile üretilmiştir.
All rights reserved