Eksiksiz Python Geliştirici Rehberi

Dil Hakimiyeti, Best Practice’ler, Tasarım Kalıpları, Ekosistem & AI/Agentic Araçları

Profesyonel Python geliştiricileri için referans kalitesinde, derinlemesine bir rehber — dilin çekirdek iç işleyişinden modern AI agent yığınına kadar.

İçindekiler

1. Dilin Temelleri ve İç İşleyişi
2. Modern Python Özellikleri (3.10 → 3.13+)
3. Tip Sistemi (Typing) Derinlemesine
4. Best Practice’ler ve Kod Kalitesi
5. Python’da Tasarım Kalıpları
6. Eşzamanlılık ve Paralellik
7. Test Ekosistemi
8. Paketleme, Ortamlar ve Araçlar
9. Web Framework’leri ve API’ler
10. Veri Mühendisliği ve Bilimsel Yığın
11. Veritabanları ve ORM’ler
12. CLI, Loglama, Gözlemlenebilirlik
13. DevOps, CI/CD ve Deployment
14. AI / Agentic Mühendislik Yığını
15. Önerilen Proje Yapısı
16. Bilinmesi Gereken Kütüphaneler — Özet Tablo

1. Dilin Temelleri ve İç İşleyişi

1.1 Data Model (Veri Modeli)

Python’ın “sihirli” (dunder/çift alt çizgili) metotları, nesnelerin built-in operasyonlarla nasıl davranacağını belirler. Data model’e hakim olmak, idiomatic Python ile “Java/C++ gibi yazılmış Python” arasındaki farkı yaratır.

class Vector:
    __slots__ = ("x", "y")  # bellek verimli, __dict__'i devre dışı bırakır

    def __init__(self, x: float, y: float):
        self.x, self.y = x, y

    def __repr__(self) -> str:
        return f"Vector({self.x!r}, {self.y!r})"

    def __add__(self, other: "Vector") -> "Vector":
        return Vector(self.x + other.x, self.y + other.y)

    def __eq__(self, other: object) -> bool:
        return isinstance(other, Vector) and (self.x, self.y) == (other.x, other.y)

    def __hash__(self) -> int:
        return hash((self.x, self.y))

    def __iter__(self):
        yield self.x
        yield self.y

Bilinmesi gereken dunder grupları:

• Oluşturma/temsil: __init__, __new__, __repr__, __str__, __format__
• Karşılaştırma: __eq__, __lt__, functools.total_ordering
• Container protokolü: __len__, __getitem__, __setitem__, __contains__, __iter__
• Çağrılabilir nesneler: __call__
• Context manager’lar: __enter__, __exit__ (async için __aenter__/__aexit__)
• Descriptor’lar: __get__, __set__, __delete__ (property, ORM’ler, functools.cached_property‘nin arkasındaki güç)
• Attribute erişim hook’ları: __getattr__, __getattribute__, __setattr__

1.2 Her Şey Bir Nesnedir, İsimler Referanstır

Değişkenler, nesnelere bağlanan etiketlerdir; kutu/konteyner değildir. Bu durum, mutable default argument hatalarını, shallow vs. deep copy semantiğini (copy.copy vs copy.deepcopy) ve is‘in kimlik (identity), ==‘in ise eşitlik kontrolü yaptığını açıklar.

# Klasik tuzak
def append_item(item, bucket=[]):   # KÖTÜ: mutable default tüm çağrılar arasında paylaşılır
    bucket.append(item)
    return bucket

def append_item_fixed(item, bucket=None):
    bucket = bucket if bucket is not None else []
    bucket.append(item)
    return bucket

1.3 Iterator’lar, Generator’lar ve Coroutine’ler

def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

# Generator expression — lazy, bellek verimli
squares = (x * x for x in range(1_000_000))

# yield from bir alt-generator'a delege eder
def chain(*iterables):
    for it in iterables:
        yield from it

Generator’lar; asyncio coroutine’lerinin, itertools pipeline’larının ve büyük veri setlerinin bellek-güvenli akışının (streaming) temelini oluşturur.

1.4 Decorator’lar ve Closure’lar

import functools
import time

def retry(times: int = 3, delay: float = 1.0):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            last_exc = None
            for attempt in range(times):
                try:
                    return func(*args, **kwargs)
                except Exception as exc:
                    last_exc = exc
                    time.sleep(delay)
            raise last_exc
        return wrapper
    return decorator

@retry(times=5, delay=0.5)
def flaky_call():
    ...

__name__, __doc__ ve signature introspection’ı korumak için her zaman functools.wraps kullanın.

1.5 Context Manager’lar

from contextlib import contextmanager

@contextmanager
def timer(label: str):
    start = time.perf_counter()
    try:
        yield
    finally:
        print(f"{label}: {time.perf_counter() - start:.4f}s")

with timer("db-sorgusu"):
    run_query()

1.6 Metaclass’lar ve __init_subclass__

Metaclass’lar class oluşturma sürecini kontrol eder; __init_subclass__ ise plugin/registry kalıpları için daha hafif, modern bir alternatiftir:

class PluginBase:
    registry: dict[str, type] = {}

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        PluginBase.registry[cls.__name__] = cls

1.7 GIL ve Bellek Modeli

• CPython bir Global Interpreter Lock (GIL) kullanır — aynı anda yalnızca bir thread Python bytecode’u çalıştırabilir.
• Python 3.13, deneysel bir free-threaded build (PEP 703, “no-GIL” CPython) tanıttı — thread’ler ile gerçek çoklu çekirdek paralelliği için büyük bir adım.
• CPython, döngü tespiti için reference counting + generational garbage collector (gc modülü) kullanır.
• Pratik anlamı: CPU-yoğun işler → multiprocessing veya native uzantılar; I/O-yoğun işler → threading veya asyncio.

2. Modern Python Özellikleri (3.10 → 3.13+)

2.1 Structural Pattern Matching

def handle_event(event: dict):
    match event:
        case {"type": "click", "x": x, "y": y}:
            print(f"Tıklama konumu: ({x}, {y})")
        case {"type": "key", "key": ("Enter" | "Return")}:
            submit_form()
        case {"type": str() as t}:
            print(f"Bilinmeyen event tipi: {t}")
        case _:
            raise ValueError("Hatalı biçimlendirilmiş event")

2.2 Yeni Generic Syntax’ı (3.12+)

class Stack[T]:
    def __init__(self) -> None:
        self._items: list[T] = []

    def push(self, item: T) -> None:
        self._items.append(item)

    def pop(self) -> T:
        return self._items.pop()

def first[T](items: list[T]) -> T:
    return items[0]

2.3 Exception Group’lar

try:
    async with asyncio.TaskGroup() as tg:
        tg.create_task(fetch("a"))
        tg.create_task(fetch("b"))
except* ValueError as eg:
    for e in eg.exceptions:
        log.error(e)

3. Tip Sistemi (Typing) Derinlemesine

Tip ipuçları (type hints) opsiyoneldir ama profesyonel kod tabanlarında olmazsa olmazdır — IDE desteği, statik analiz ve kendi kendini dokümante eden API’ler sağlar.

from typing import TypedDict, Protocol, Literal, overload
from collections.abc import Sequence, Callable

class UserDict(TypedDict):
    id: int
    name: str
    role: Literal["admin", "member", "guest"]

class Comparable(Protocol):
    def __lt__(self, other) -> bool: ...

def sort_items[T: Comparable](items: Sequence[T]) -> list[T]:
    return sorted(items)

@overload
def parse(value: str) -> int: ...
@overload
def parse(value: bytes) -> int: ...
def parse(value):
    return int(value)

Statik tip kontrolcüleri: mypy (referans implementasyon), pyright/pylance (hızlı, VS Code tarafından kullanılır), pyre (Meta). Maksimum güvenlik için CI’da mypy --strict veya pyright --strict kullanın.

Runtime doğrulama: Statik tipler runtime’da silinir (erased) — güvenilmeyen input’ları parse ederken veya API sınırlarında runtime zorlaması gerektiğinde Pydantic veya typeguard/beartype kullanın.

4. Best Practice’ler ve Kod Kalitesi

4.1 Stil ve Yapı

• PEP 8 (stil) ve PEP 257‘yi (docstring) takip edin. Google-style veya NumPy-style docstring’leri tutarlı biçimde kullanın.
• Artık tek bir araç hem linting hem formatlamayı kapsıyor: Ruff (Rust tabanlı; Flake8 + isort + pyupgrade’in yerini alıyor, formatlama için büyük ölçüde Black’in de yerini alıyor).
• Fonksiyonları küçük ve tek amaçlı tutun; derin inheritance yerine composition’ı tercih edin.
• Ham string path manipülasyonu yerine pathlib.Path kullanın.
• % veya .format() yerine f-string’leri tercih edin.

4.2 Hata Yönetimi

class DomainError(Exception):
    """Tüm domain'e özgü hatalar için temel sınıf."""

class InsufficientFundsError(DomainError):
    def __init__(self, balance: float, requested: float):
        self.balance = balance
        self.requested = requested
        super().__init__(f"Bakiye {balance} < istenen {requested}")

• Asla çıplak except: kullanmayın. Belirli exception’ları yakalayın.
• Her domain/modül için özel exception hiyerarşileri kullanın.
• Erken başarısız olun (fail fast); input’ları sınırlarda (API katmanı, CLI katmanı) doğrulayın.

4.3 Konfigürasyon Yönetimi

• Tip güvenli, doğrulanmış env-tabanlı config için pydantic-settings.
• Geliştirme ortamında .env yüklemesi için python-dotenv.

from pydantic_settings import BaseSettings

class Settings(BaseSettings):
    database_url: str
    debug: bool = False
    model_config = {"env_file": ".env"}

4.4 Loglama (production kodunda asla print kullanmayın)

import logging
logger = logging.getLogger(__name__)
logger.info("Sipariş işleniyor: %s", order_id)

Production’da JSON log’lar, correlation ID’ler ve log aggregation uyumluluğu için structured logging (structlog) kullanın.

4.5 Güvenlik Uygulamaları

• Asla secret’ları hardcode etmeyin — env değişkenleri / secret manager’lar kullanın (AWS Secrets Manager, Vault, Doppler).
• Statik güvenlik taraması için bandit kullanın.
• Bağımlılıkları lockfile’larla pinleyin; pip-audit / safety ile tarayın.
• Tüm dış input’ları doğrulayın (her güven sınırında Pydantic modelleri).

4.6 Dokümantasyon

• Doküman siteleri için mkdocs + mkdocs-material veya Sphinx.
• Docstring’ler + tip ipuçları = otomatik üretilen API referansları.
• Bir CHANGELOG.md (Keep a Changelog formatı) ve semantic versioning tutun.

5. Python’da Tasarım Kalıpları

Python’ın dinamik doğası, birçok klasik GoF kalıbını daha basit veya gereksiz hale getirir — ama fikirler hâlâ değerlidir.

5.1 Creational (Yaratımsal)

• Factory Function — Factory class’lar yerine düz fonksiyonlar/callable’lar.
• Builder — akıcı zincirleme metotlar, ya da basitçe keyword-argument’ı zengin dataclass’lar.
• Singleton — modül seviyesinde instance (modüller doğal olarak singleton’dır), veya bir constructor fonksiyonu üzerinde functools.lru_cache(maxsize=None).

@functools.lru_cache(maxsize=None)
def get_settings() -> Settings:
    return Settings()

5.2 Structural (Yapısal)

• Adapter — uyumsuz bir interface’i sarmalar.
• Decorator (yapısal, @decorator syntax’ı değil) — davranış eklemek için nesneleri sarmalar.
• Facade — karmaşık bir alt sistemin önünde basitleştirilmiş bir API (SDK wrapper tasarımında yaygın).

5.3 Behavioral (Davranışsal)

• Strategy — Strategy class’ları yerine fonksiyonları birinci sınıf nesneler olarak geçirmek.

def process(data: list[int], strategy: Callable[[list[int]], int]) -> int:
    return strategy(data)

process(data, strategy=sum)
process(data, strategy=max)

• Observer — event sistemleri, blinker kütüphanesi, veya callback listeleriyle basit pub/sub.
• Command — bir isteği bir nesne olarak kapsüller (task queue’larda / undo sistemlerinde yoğun kullanılır).
• State Machine — açık FSM’ler için transitions veya python-statemachine kütüphaneleri.

5.4 Dependency Injection

Duck typing sayesinde Python nadiren bir DI framework’üne ihtiyaç duyar, ancak daha büyük uygulamalar için:

• FastAPI’nin Depends() sistemi.
• Web dışı uygulamalarda açık container’lar için dependency-injector kütüphanesi.

5.5 Repository & Unit of Work (DDD’ye yakın)

İş mantığını persistence’tan ayırmak için servis katmanı mimarilerinde yaygın (Unit of Work olarak SQLAlchemy session scope’u).

6. Eşzamanlılık ve Paralellik

import asyncio

async def fetch_all(urls: list[str]):
    async with httpx.AsyncClient() as client:
        tasks = [client.get(url) for url in urls]
        return await asyncio.gather(*tasks)

# Yapılandırılmış eşzamanlılık (structured concurrency, 3.11+)
async def main():
    async with asyncio.TaskGroup() as tg:
        tg.create_task(fetch_all(urls_a))
        tg.create_task(fetch_all(urls_b))

• Ray, ML/AI pipeline’larında dağıtık compute için giderek daha fazla tercih ediliyor (birçok agent-serving framework’ünün de temelinde yer alıyor).
• Dask, out-of-core / dağıtık dataframe’ler için pandas/numpy API’lerini yansıtır.

7. Test Ekosistemi

• pytest — fiili standart; fixture’lar, parametrizasyon, plugin’ler.
• pytest-asyncio — async kodu test etme.
• pytest-cov — coverage entegrasyonu.
• hypothesis — property-based testing (edge case’leri otomatik üretir).
• tox / nox — birden fazla Python sürümü/ortamında test.
• factory_boy / faker — test verisi üretimi.
• responses / respx — HTTP çağrılarını mock’lama.
• testcontainers-python — integration testleri için gerçek Docker bağımlılıkları (Postgres, Redis) ayağa kaldırma.

import pytest

@pytest.fixture
def client():
    return TestClient(app)

@pytest.mark.parametrize("value,expected", [(1, 2), (2, 4), (3, 6)])
def test_double(value, expected):
    assert double(value) == expected

@pytest.mark.asyncio
async def test_fetch():
    result = await fetch_data()
    assert result is not None

8. Paketleme, Ortamlar ve Araçlar

8.1 Modern Araç Zinciri (2025-2026 konsensüsü)

• uv (Astral) — yeni standart: son derece hızlı paket yükleyici, resolver ve proje yöneticisi (pip, pip-tools, virtualenv’in yerini alıyor, birçok ekip için Poetry’nin de büyük ölçüde yerini alıyor).
• Ruff (Astral) — linter + formatter; çoğu yeni projede Flake8/isort/Black’in yerini alıyor.
• Poetry — pyproject.toml ile bağımlılık + paketleme yönetimi için hâlâ yaygın kullanılıyor.
• pyenv — birden fazla Python interpreter sürümünü yönetme.
• pipx — CLI araçlarını izole ortamlarda yükleme/çalıştırma.

# uv workflow
uv init my-project
uv add fastapi httpx
uv run pytest
uv lock

8.2 pyproject.toml (PEP 621) tek doğruluk kaynağıdır

[project]
name = "my-project"
version = "0.1.0"
requires-python = ">=3.12"
dependencies = ["fastapi>=0.115", "pydantic>=2.0"]

[tool.ruff]
line-length = 100

[tool.mypy]
strict = true

8.3 Pre-commit Hook’ları

repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    hooks:
      - id: ruff
      - id: ruff-format

9. Web Framework’leri ve API’ler

from fastapi import FastAPI, Depends
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float

@app.post("/items")
async def create_item(item: Item):
    return {"id": 1, **item.model_dump()}

Sunum (serving): production için Uvicorn (ASGI server), Gunicorn (Uvicorn worker’larıyla birlikte).

10. Veri Mühendisliği ve Bilimsel Yığın

• NumPy — n-boyutlu array hesaplamasının temeli.
• pandas — tablosal veri manipülasyonu (endüstri standardı).
• Polars — Rust tabanlı, çoklu-thread’li DataFrame kütüphanesi; büyük veride pandas’tan çok daha hızlı, giderek modern varsayılan haline geliyor.
• PyArrow — kolonsal in-memory format, pandas/Polars/Spark arası interop katmanı.
• DuckDB — gömülü (embedded) analitik SQL motoru; Parquet/CSV üzerinde yerel analitik için mükemmel.
• Matplotlib / Seaborn / Plotly — görselleştirme.
• scikit-learn — klasik ML.
• PyTorch — derin öğrenme (araştırmada baskın, production’da da giderek yaygın framework).
• JAX — yüksek performanslı sayısal hesaplama + autodiff, araştırmada popüler.

import polars as pl

df = pl.read_parquet("events.parquet")
result = (
    df.filter(pl.col("status") == "active")
      .group_by("country")
      .agg(pl.col("revenue").sum())
)

11. Veritabanları ve ORM’ler

• SQLAlchemy 2.0 — standart ORM/Core toolkit, asyncpg/aiomysql ile tam async destekli.
• SQLModel — SQLAlchemy + Pydantic’in birleşimi, FastAPI’nin yazarından.
• Alembic — SQLAlchemy için şema migrasyonları.
• Django ORM — Django’ya sıkı bağlı, CRUD-yoğun uygulamalar için çok verimli.
• Tortoise ORM — async-first, Django ORM’e benzer API.
• asyncpg / psycopg3 — PostgreSQL sürücüleri.
• Redis-py — caching, pub/sub, kuyruklar.
• MongoDB (PyMongo / Motor) — döküman deposu, Motor ile async.

from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import Mapped, mapped_column, DeclarativeBase

class Base(DeclarativeBase): pass

class User(Base):
    __tablename__ = "users"
    id: Mapped[int] = mapped_column(primary_key=True)
    email: Mapped[str]

12. CLI, Loglama, Gözlemlenebilirlik

• Typer — tip ipuçları üzerine kurulu modern CLI framework’ü (FastAPI’nin yazarından).
• Click — olgun, kompoze edilebilir CLI framework’ü (Typer’ın temelinde).
• Rich — güzel terminal çıktısı, tablolar, progress bar’lar, traceback’ler.
• structlog — structured logging.
• OpenTelemetry — framework-agnostik dağıtık tracing/metrik standardı.
• Sentry — hata takibi/izleme.
• Prometheus client — scraping için metrik sunumu.

import typer
from rich import print

app = typer.Typer()

@app.command()
def greet(name: str, loud: bool = False):
    msg = f"Merhaba, {name}!"
    print(msg.upper() if loud else msg)

if __name__ == "__main__":
    app()

13. DevOps, CI/CD ve Deployment

• Docker — konteynerleştirme; küçük image’lar için multi-stage build + uv/pip --no-cache-dir kullanın.
• GitHub Actions / GitLab CI — standart CI/CD.
• Kubernetes — daha büyük deployment’lar için orkestrasyon.
• Terraform — infrastructure-as-code (genellikle Python-native IaC için pulumi ile eşleştirilir).
• Pulumi — gerçek Python ile yazılan infrastructure-as-code.
• Standartlaştırılmış geliştirme komutları için Makefile veya just (komut çalıştırıcı).

FROM python:3.13-slim AS builder
COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
WORKDIR /app
COPY pyproject.toml uv.lock ./
RUN uv sync --frozen --no-dev

FROM python:3.13-slim
COPY --from=builder /app /app
CMD ["uv", "run", "uvicorn", "main:app", "--host", "0.0.0.0"]

14. AI / Agentic Mühendislik Yığını

Bu bölüm, 2025-2026 döneminde LLM tabanlı uygulamalar ve otonom agent’lar inşa etmek için olmazsa olmaz kütüphaneleri ve kalıpları kapsar.

14.1 Temel LLM SDK’ları

• anthropic — resmi Claude SDK’sı (Messages API, tool use/function calling, streaming, batch API, prompt caching).
• openai — resmi OpenAI SDK’sı (Chat Completions/Responses API, function calling, Assistants/Realtime API).
• litellm — tek bir OpenAI-uyumlu API ile 100’den fazla LLM sağlayıcısı arasında birleşik arayüz — sağlayıcıdan bağımsız uygulamalar için son derece popüler.

import anthropic

client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    tools=[{
        "name": "get_weather",
        "description": "Bir konum için güncel hava durumunu getir",
        "input_schema": {
            "type": "object",
            "properties": {"location": {"type": "string"}},
            "required": ["location"],
        },
    }],
    messages=[{"role": "user", "content": "İstanbul'da hava nasıl?"}],
)

14.2 Yapılandırılmış Çıktı (Structured Output) ve Doğrulama

• Pydantic v2 — neredeyse her agent framework’ünün belkemiği; tool şemalarını tanımlar, LLM çıktısını doğrular, FastAPI request/response modellerine güç verir.
• instructor — LLM client’larını, completion’lardan doğrudan doğrulanmış Pydantic nesneleri döndürecek şekilde patch’ler (güvenilir structured extraction için çok önemli).
• outlines — açık ağırlıklı (open-weight) modeller için token seviyesinde kısıtlanmış/yönlendirilmiş üretim (gramer, regex, JSON şema zorlaması).

import instructor
from pydantic import BaseModel

class Person(BaseModel):
    name: str
    age: int

client = instructor.from_anthropic(anthropic.Anthropic())
person = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    response_model=Person,
    messages=[{"role": "user", "content": "Çıkar: John 30 yaşında"}],
)

14.3 Agent Orkestrasyon Framework’leri

# LangGraph tarzı açık agent state machine (kavramsal)
from langgraph.graph import StateGraph, END

class AgentState(TypedDict):
    messages: list
    next_step: str

graph = StateGraph(AgentState)
graph.add_node("plan", plan_node)
graph.add_node("act", act_node)
graph.add_node("reflect", reflect_node)
graph.add_conditional_edges("reflect", should_continue, {"continue": "plan", "done": END})
graph.set_entry_point("plan")
app = graph.compile()

14.4 Model Context Protocol (MCP)

MCP (Anthropic tarafından tanıtıldı, artık endüstride yaygın olarak benimseniyor), LLM uygulamalarını harici araçlara, veri kaynaklarına ve servislere bağlamak için açık bir standarttır — “AI uygulamaları için USB-C” gibi düşünün. Temel yapı taşları:

• mcp Python SDK’sı — MCP server/client’lar inşa etme.
• Server’lar, standart JSON-RPC tabanlı bir transport (stdio, HTTP/SSE) üzerinden tool’lar, resource’lar ve prompt’lar sunar.
• Agent framework’lerinin (Claude, LangGraph, CrewAI, özel agent’lar) harici araçları keşfetme ve çağırma yöntemi olarak hızla standart haline geliyor; özel tool-calling glue kodunun yerini alıyor.

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("weather-server")

@mcp.tool()
def get_forecast(city: str) -> str:
    """Bir şehir için hava tahminini getir."""
    return fetch_weather(city)

if __name__ == "__main__":
    mcp.run()

14.5 Vektör Veritabanları ve Retrieval (RAG)

• Chroma — basit, gömülü, yerel/dev RAG için popüler.
• Qdrant — yüksek performanslı, Rust tabanlı, güçlü filtreleme desteği.
• Weaviate — hibrit arama (vektör + anahtar kelime), şema tabanlı.
• Pinecone — tamamen yönetilen, serverless vektör veritabanı.
• pgvector — bir Postgres uzantısı olarak vektör arama (zaten Postgres kullanıyorsanız harika).
• FAISS (Meta) — süreç-içi benzerlik arama kütüphanesi, temel/düşük seviyeli.

import chromadb

client = chromadb.PersistentClient(path="./db")
collection = client.get_or_create_collection("docs")
collection.add(documents=[...], ids=[...], embeddings=[...])
results = collection.query(query_texts=["RAG nedir?"], n_results=5)

14.6 Embedding’ler ve Reranking

• sentence-transformers — açık kaynak embedding/reranking modelleri.
• OpenAI / Voyage AI / Cohere embedding API’leri — barındırılan, yüksek kaliteli embedding’ler.
• Cohere Rerank / cross-encoder reranker’lar — vektör-arama sonrası retrieval hassasiyetini iyileştirir.

14.7 LLM Uygulamaları için Gözlemlenebilirlik ve Değerlendirme

• LangSmith — tracing, değerlendirme, dataset yönetimi (LangChain ekosistemi).
• Langfuse — açık kaynak LLM gözlemlenebilirliği, tracing, prompt yönetimi, evaluation’lar.
• Helicone — proxy tabanlı LLM loglama/gözlemlenebilirlik/maliyet takibi.
• Ragas — RAG’e özgü değerlendirme metrikleri (faithfulness, context precision/recall).
• promptfoo — CI-uyumlu prompt test/regresyon framework’ü.
• DeepEval — LLM çıktıları için pytest tarzı unit test framework’ü.

from ragas import evaluate
from ragas.metrics import faithfulness, context_precision

results = evaluate(dataset, metrics=[faithfulness, context_precision])

14.8 Prompt Mühendisliği ve Şablonlar

• Jinja2 — dinamik prompt oluşturma için yaygın kullanılan templating motoru.
• anthropic/openai prompt caching — tekrar eden büyük system prompt’lar/context için maliyeti/gecikmeyi azaltır.
• Prompt’ları kod gibi versiyonlayın: dosyalarda/DB’de saklayın, PR’lar üzerinden review edin, deploy etmeden önce promptfoo/Langfuse ile değerlendirin.

14.9 Yerel ve Açık-Ağırlıklı Model Sunumu

• Ollama — açık ağırlıklı modelleri yerel olarak çalıştırmanın en basit yolu.
• vLLM — yüksek verimli inference server’ı (PagedAttention); self-hosted LLM sunumu için production standardı.
• Hugging Face transformers / accelerate — model yükleme, fine-tuning, inference.
• LoRA / PEFT / peft kütüphanesi — büyük modellerin verimli fine-tuning’i.
• llama.cpp / GGUF — CPU-dostu kuantize model inference’ı.

14.10 Multi-Agent İletişimi ve Guardrail’lar

• Guardrails AI — LLM input/output’ları için doğrulama/guardrail framework’ü (PII tespiti, toksisite, şema zorlaması).
• NeMo Guardrails (NVIDIA) — konuşma güvenliği/konu kontrolü için programlanabilir raylar.
• A2A (Agent2Agent) protokolü — MCP’nin tool-erişim odağını tamamlayan, agent’lar arası birlikte çalışabilirlik için gelişmekte olan standart (Google öncülüğünde).

14.11 Minimal ama Gerçekçi Bir Agentic Yığın (2026)

LLM: Anthropic Claude / OpenAI GPT (`anthropic`/`openai`/`litellm` üzerinden)
Orkestrasyon: LangGraph veya Pydantic AI
Araçlar (Tools): MCP server'ları (özel + topluluk)
Yapılandırılmış G/Ç: Pydantic v2 + `instructor`
Retrieval: Qdrant/pgvector + sentence-transformers + Cohere Rerank
Gözlemlenebilirlik: Langfuse
Değerlendirme: Ragas + promptfoo (CI gate)
Sunum (Serving): FastAPI + Uvicorn, Docker, bir API gateway arkasında

15. Önerilen Proje Yapısı

my-project/
├── pyproject.toml
├── uv.lock
├── README.md
├── .pre-commit-config.yaml
├── .github/workflows/ci.yml
├── src/
│   └── my_project/
│       ├── __init__.py
│       ├── api/            # FastAPI router'ları
│       ├── core/           # config, loglama, güvenlik
│       ├── domain/         # iş modelleri, exception'lar
│       ├── services/       # iş mantığı
│       ├── repositories/   # veri erişimi
│       ├── agents/         # agent graph'ları, tool'lar, prompt'lar
│       └── schemas/        # Pydantic modelleri
└── tests/
    ├── unit/
    ├── integration/
    └── conftest.py

16. Bilinmesi Gereken Kütüphaneler — Özet Tablo

Son Notlar

• Karmaşıklık yerine okunabilirliği ve açıklığı önceliklendirin — “Basit, karmaşıktan iyidir” (The Zen of Python).
• Araç zincirinizi sade tutun: uv + ruff + pytest + mypy/pyright, profesyonel ihtiyaçların %90’ını karşılar.
• Özellikle agentic alanda, production-kritik her şey için “sihirli” otonom döngüler yerine açık, incelenebilir state machine’leri (LangGraph, Pydantic AI) tercih edin — kontrol edilebilirlik ve gözlemlenebilirlik, ham otonomiden daha önemlidir.