Tam Kapsamlı Otonom (Agentic) Yapay Zeka Uygulamaları İçin En İyi 15 Python Framework’ü

Otonom yapay zeka (agentic AI) uygulamaları geliştirmek, birkaç yıl öncesine göre artık çok daha kolay. Ajan döngülerini, araç entegrasyonlarını, hafızayı, geri getirme (retrieval) ve orkestrasyonu sıfırdan yazmak yerine, geliştiriciler bu bileşenlerin çoğunu hazır sunan Python framework’lerini kullanabiliyor.

Bu yazıdaki framework’lerin çoğunu RAG uygulamaları, otonom ajanlar, çoklu ajan sistemleri ve dağıtıma hazır yapay zeka araçları geliştirmek için kullandım.

Esnek ajan iş akışları için sıklıkla LangChain, veri bağlantılı uygulamalar için LlamaIndex ve Haystack, sağlayıcı modellere daha hızlı entegre olmak istediğimde OpenAI Agents SDK veya Google ADK kullanıyorum.

Bu framework’lerin bazıları o kadar gelişti ki çoğu durumda özel bir çözüm inşa etmek gereksiz hale geldi. Bir API anahtarı, biraz model kredisi ve doğru framework ile bir ajan oluşturabilir, onu araçlara veya özel verinize bağlayabilir, test edip bir API ya da kullanıcı arayüzü üzerinden dağıtabilirsiniz.

Bu makale, beş kategoride 15 Python framework’ünü karşılaştırıyor: genel amaçlı ajan framework’leri, resmi ajan SDK’ları, çoklu ajan orkestrasyon framework’leri, veri ve RAG framework’leri ile hafif açık model framework’leri.

Her bölümde ayrıca framework’ün nasıl çalıştığını hızla anlamanız için kopyalayıp yapıştırarak test edebileceğiniz kısa bir Python örneği yer alıyor.

Genel Amaçlı Ajan Framework’leri

Bu framework’ler; ajanlar oluşturmak, araçları bağlamak, durumu yönetmek ve çok adımlı iş akışlarını kontrol etmek için geniş yapı taşları sunar.

1. LangChain

Pek çok geliştirici için modern LLM uygulama geliştirme, dil modellerini harici veriler, araçlar, API’ler ve uygulama mantığıyla bağlamak üzere tasarlanmış açık kaynak Python framework’ü LangChain ile başladı. OpenAI API’sini web siteleri, belgeler, vektör veritabanları ve diğer veri kaynaklarıyla kullanmak için yaygın biçimde benimsenen ilk framework’lerden biri oldu ve daha bağlama duyarlı uygulamalar geliştirmeyi kolaylaştırdı.

Bugün LangChain; RAG sistemleri, araç kullanan ajanlar, iş akışları, entegrasyonlar, izleme ve değerlendirme dâhil olmak üzere uçtan uca otonom yapay zeka uygulamaları geliştirmek için eksiksiz bir ekosisteme dönüştü. Daha fazlasını öğrenmek için AI Engineering with LangChain öğrenme yoluna göz atmanızı öneririm.

Aşağıdaki örnek, bir soruyu yanıtlamadan önce ilgili bilgileri bulmak için dokümantasyon arama aracını kullanabilen basit bir LangChain ajanı oluşturur.

# pip install -U langchain "langchain[openai]"

from langchain.agents import create_agent

def search_docs(query: str) -> str:
    """Search the company documentation."""
    return f"Documentation found for: {query}"

agent = create_agent(
    model="openai:gpt-5.5",
    tools=[search_docs],
    system_prompt="Use the documentation tool when needed.",
)

result = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "What is our remote-work policy?"
    }]
})

print(result["messages"][-1].content)

2. LangGraph

LangChain ajanlar ve araçlar oluşturmayı kolaylaştırırken, LangGraph bu ajanların nasıl çalıştığı üzerinde daha fazla kontrol sağlar. Geliştiricilerin bir uygulamayı bağlantılı adımlar grafiği olarak yapılandırmasına imkân tanır; böylece döngüler, araç çağrıları, paylaşılan durum, insan onayları ve çoklu ajan iş akışlarını kontrol etmek kolaylaşır.

Özellikle, ne yapacağına tekrar tekrar karar vermesi, doğru aracı seçmesi, sonucu kontrol etmesi ve görev tamamlanana dek devam etmesi gereken otonom ajanlar geliştirirken çok yararlı buluyorum. LangGraph, daha uzun süre çalışan uygulamalar için kalıcılık, akış (streaming), kontrol noktaları ve kurtarma da destekler. Daha fazla ayrıntı için LangGraph eğitimimize bakabilirsiniz.

Aşağıdaki örnek, yeterli bilgiye ulaşana kadar hesap makinesi araçlarını tekrar tekrar çağırabilen bir ajan oluşturur:

# pip install -U langgraph langchain langchain-openai

from langchain.chat_models import init_chat_model
from langchain.tools import tool
from langgraph.graph import MessagesState, StateGraph, START
from langgraph.prebuilt import ToolNode, tools_condition

model = init_chat_model("openai:gpt-5.5", temperature=0)

@tool
def add(a: int, b: int) -> int:
    """Add two numbers."""
    return a + b

@tool
def multiply(a: int, b: int) -> int:
    """Multiply two numbers."""
    return a * b

tools = [add, multiply]
model_with_tools = model.bind_tools(tools)

def call_model(state: MessagesState):
    response = model_with_tools.invoke(state["messages"])
    return {"messages": [response]}

builder = StateGraph(MessagesState)
builder.add_node("agent", call_model)
builder.add_node("tools", ToolNode(tools))

builder.add_edge(START, "agent")
builder.add_conditional_edges("agent", tools_condition)
builder.add_edge("tools", "agent")

agent = builder.compile()

result = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "Add 12 and 8, then multiply the result by 3."
    }]
})

print(result["messages"][-1].content)

Grafik, isteği modele gönderir, gereken araçları çalıştırır ve model nihai bir yanıt üretinceye kadar modele geri döner.

3. Agno

Agno, ajanlar, çoklu ajan ekipleri ve yapılandırılmış iş akışları geliştirmek için bir Python framework’üdür. Ayrıca, geliştiricilerin ajanları API’ler aracılığıyla sunmasına, oturumları ve izleri depolamasına ve bunları üretim uygulamaları olarak yönetmesine yardımcı olan AgentOS’u içerir. Kendi altyapınızda çalışabildiği için kuruluşlar veri ve güvenlik üzerinde daha fazla kontrol sahibi olur.

Aşağıdaki örnek, kısa ve öz bir yanıt üretmeden önce web’de arama yapabilen bir araştırma ajanı oluşturur.

# pip install -U agno ddgs openai

from agno.agent import Agent
from agno.models.openai import OpenAIResponses
from agno.tools.duckduckgo import DuckDuckGoTools

agent = Agent(
    name="AI Research Assistant",
    model=OpenAIResponses(id="gpt-5.5"),
    tools=[DuckDuckGoTools()],
    instructions="Search when needed and keep the answer concise.",
)

agent.print_response(
    "Find one recent development in open-source AI and summarize it.",
    stream=True,
)

Ajan, güncel bilgileri bulmak için arama aracını kullanır ve kullanıcıya kısa bir özet akışı sunar.

4. Pydantic AI

Pydantic AI, Pydantic ekibinden, ajanlar ve üretken yapay zeka uygulamaları geliştirmek için Python-yerel bir framework’tür. Pydantic modelleri veya FastAPI ile çalışmaya benzer hissettirir; çünkü ajanlar, araçlar, bağımlılıklar ve çıktılar standart Python fonksiyonları, tür ipuçları, dekoratörler ve BaseModel sınıflarıyla tanımlanır. Ardından Pydantic doğrulamasını kullanarak araç argümanlarını ve model çıktılarının yapısını güvenilir kılar.

Framework hakkında daha fazla bilgi edinmek için Pydantic AI eğitimini önerebilirim.

Aşağıdaki örnek, doğrulanmış bir makale planını Pydantic modeli olarak döndüren bir ajan oluşturur.

# pip install -U pydantic-ai

from pydantic import BaseModel, Field
from pydantic_ai import Agent


class ArticlePlan(BaseModel):
    title: str
    key_points: list[str]
    reading_time_minutes: int = Field(ge=1)


agent = Agent(
    "openai:gpt-5.6-sol",
    output_type=ArticlePlan,
    instructions="Create concise article plans for technical readers.",
)

result = agent.run_sync(
    "Create a short article plan about building AI agents in Python."
)

print(result.output)

Ajan, bir ArticlePlan nesnesi üretir ve her alanın gerekli Python türü ve kurallarla eşleştiğini doğruladıktan sonra döndürür.

Resmi Ajan SDK’ları

Resmi ajan SDK’ları, yapay zeka sağlayıcıları tarafından bakım görür ve genellikle kendi modelleri, API’leri, araçları, dağıtım sistemleri ve gözlemlenebilirlik platformlarıyla en basit entegrasyonu sunar.

5. OpenAI Agents SDK

OpenAI Agents SDK, tekli ve çoklu ajan uygulamaları geliştirmek için hafif, Python-öncelikli bir frameworktür. Yerleşik bir ajan döngüsü, fonksiyon araçları, devretmeler (handoff), koruma rayları (guardrails), oturumlar, insan onayları ve aşırı soyutlama eklemeden izleme (tracing) sunar.

OpenAI Agents SDK’yı kullanmayı seviyorum; çünkü basit, hızla entegre edilebiliyor ve anlaşılması kolay. Önemli bir sorun yaşamadan bununla birçok uygulama geliştirdim. Ayrıca OpenAI Dashboard’da görüntülenebilen izleri otomatik olarak oluşturur; bu sayede model yanıtlarını, araç çağrılarını, devretmeleri ve tüm yürütme akışını incelemek kolaydır.

Aşağıdaki örnek, şaşırtıcı bir tarihsel bilgiyi getirmek için bir Python fonksiyonunu çağırabilen bir tarih ajanı oluşturur.

# pip install openai-agents

import asyncio
from agents import Agent, Runner, function_tool


@function_tool
def history_fun_fact() -> str:
    """Return a surprising historical fact."""
    return "The first computer programmer, Ada Lovelace, lived in the 1800s."


agent = Agent(
    name="History Assistant",
    instructions=(
        "Answer history questions clearly and briefly. "
        "Use history_fun_fact when it is helpful."
    ),
    tools=[history_fun_fact],
)


async def main():
    result = await Runner.run(
        agent,
        "Tell me something surprising about the history of computing.",
    )
    print(result.final_output)


if __name__ == "__main__":
    asyncio.run(main())

SDK ajanı çalıştırır, gerektiğinde tarih aracını çağırır, sonucunu modele geri verir ve nihai yanıtı üretir. Tüm çalıştırma, izleyici üzerinden de incelenebilir.

7. Google Agent Development Kit

Google’ın Agent Development Kit’i (ADK), tekil ajanlar, araç kullanan asistanlar, grafik tabanlı iş akışları ve çoklu ajan sistemleri geliştirmek, değerlendirmek ve dağıtmak için açık kaynak bir framework’tür. Özellikle Gemini modelleriyle çok iyi çalışır; aynı zamanda diğer model sağlayıcılarını da destekler.

ADK, basit olması ve Gemini ile doğal şekilde çalışması nedeniyle en sevdiğim framework’lerden biri haline geldi.

Önemli bir sorun yaşamadan birkaç uygulama geliştirmek için kullandım. Her ne kadar entegrasyonun daha kolay olması ve kontrol/built-in özellikler açısından daha esnek olması bakımından OpenAI Agents SDK’yı hâlâ bir adım önde bulsam da, ADK güçlü bir alternatiftir ve özellikle Gemini tabanlı uygulamalarda rekabetçidir.

Aşağıdaki örnek, bir etkinliğin başlangıç saatini getirmek için bir Python fonksiyonunu çağırabilen bir etkinlik asistanı oluşturur.

# pip install google-adk

from google.adk.agents.llm_agent import Agent


def get_event_time(city: str) -> dict:
    """Return the event starting time for a city."""
    return {
        "status": "success",
        "city": city,
        "time": "6:00 PM",
    }


root_agent = Agent(
    model="gemini-flash-latest",
    name="event_assistant",
    description="Provides information about events in different cities.",
    instruction=(
        "Answer event questions clearly. "
        "Use the get_event_time tool when the starting time is requested."
    ),
    tools=[get_event_time],
)

Ajan, belirli bir şehir için etkinlik saatini getirmesi gerektiğinde fonksiyonu bir araç olarak kullanır.

8. Claude Agent SDK

Claude Agent SDK, Claude Code’a güç veren aynı ajan döngüsü, araçlar ve bağlam yönetimini kullanarak otonom ajanlar geliştirmek için Anthropic’in Python ve TypeScript framework’üdür. Dosyaları okuması, kod düzenlemesi, komut çalıştırması, MCP araçlarına bağlanması ve uzun görevleri tamamlaması gereken ajanlar için özellikle yararlıdır.

Anthropic, OpenAI ve Google; modellerini kendi ajan framework’leriyle yakından entegre eder, bu da araçları, oturumları, izlemeyi ve diğer gelişmiş özellikleri hızla kurmayı mümkün kılar.

Bununla birlikte Claude Agent SDK, keyfi açık kaynak veya yerel olarak barındırılan modellerden ziyade özellikle Claude için tasarlanmıştır. Daha fazlasını Claude Agent SDK eğitimimizde öğrenebilirsiniz.

Aşağıdaki örnek, bir Python dosyasını gözden geçirip hataları belirleyen ve bunları otomatik olarak düzelten bir kodlama ajanı oluşturur.

# pip install claude-agent-sdk

import asyncio
from claude_agent_sdk import (
    AssistantMessage,
    ClaudeAgentOptions,
    ResultMessage,
    query,
)


async def main():
    async for message in query(
        prompt="Review app.py for errors that could cause crashes and fix them.",
        options=ClaudeAgentOptions(
            allowed_tools=["Read", "Edit", "Glob"],
            permission_mode="acceptEdits",
        ),
    ):
        if isinstance(message, AssistantMessage):
            for block in message.content:
                if hasattr(block, "text"):
                    print(block.text)
                elif hasattr(block, "name"):
                    print(f"Tool used: {block.name}")

        elif isinstance(message, ResultMessage):
            print(f"Completed: {message.subtype}")


if __name__ == "__main__":
    asyncio.run(main())

SDK ajan döngüsünü çalıştırırken Claude dosyayı okur, gerekli araçları seçer, kodu düzenler ve görev tamamlanana kadar ilerlemeyi akış halinde sunar.

Çoklu Ajan Orkestrasyon Framework’leri

Çoklu ajan framework’leri, her bir ajanın daha geniş bir iş akışında belirli bir rol, hedef, araç seti veya aşamaya atandığı birden çok uzman ajanı koordine eder. 

9. CrewAI

CrewAI, çoklu ajan ekipleri oluşturmak için popüler bir Python framework’üdür. Geliştiriciler farklı rol, hedef ve görevlere sahip ajanlar oluşturabilir; ardından bunları özerk biçimde birlikte çalışan bir ekibe dönüştürebilir. Görevler, sıralı olarak veya bir yöneticinin işi en uygun ajanlara koordine edip devrettiği hiyerarşik bir süreçle çalıştırılabilir.

Aşağıdaki Python örneği, birlikte çalışarak kısa bir rapor üreten bir araştırmacı ve bir yazar oluşturur.

# pip install crewai
# Set OPENAI_API_KEY before running

from crewai import Agent, Crew, Process, Task

researcher = Agent(
    role="AI Researcher",
    goal="Find the key facts about {topic}",
    backstory="You research technical topics carefully.",
)

writer = Agent(
    role="Technical Writer",
    goal="Turn research into a clear summary",
    backstory="You explain complex topics simply.",
)

research_task = Task(
    description="Research {topic} and identify three key findings.",
    expected_output="Three concise findings.",
    agent=researcher,
)

writing_task = Task(
    description="Write a short summary using the research findings.",
    expected_output="A clear one-paragraph report.",
    agent=writer,
    context=[research_task],
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential,
)

result = crew.kickoff(inputs={"topic": "agentic AI"})
print(result.raw)

Araştırmacı ilk görevi tamamlar ve yazar, nihai raporu oluşturmak için çıktıyı bağlam olarak kullanır.

10. MetaGPT

MetaGPT, ürün yöneticisi, mimar, proje yöneticisi ve mühendis gibi uzman ajanlar kullanarak bir yazılım şirketini modelleyen çoklu ajan bir framework’tür. Bu ajanlar, kısa bir gereksinimi planlara, teknik tasarımlara, dokümantasyona ve çalışan koda dönüştürmek için yapılandırılmış işletim prosedürlerini takip eder. 

Aşağıdaki örnek, bir yazılım ekibi oluşturur ve ondan basit bir komut satırı görev yöneticisi inşa etmesini ister.

# pip install metagpt
# Configure a supported LLM API before running

import asyncio

from metagpt.roles import (
    Architect,
    Engineer,
    ProductManager,
    ProjectManager,
)
from metagpt.team import Team


async def startup(idea: str):
    company = Team()

    company.hire([
        ProductManager(),
        Architect(),
        ProjectManager(),
        Engineer(),
    ])

    company.invest(investment=3.0)
    company.run_project(idea=idea)

    await company.run(n_round=5)


if __name__ == "__main__":
    asyncio.run(
        startup("Build a simple command-line task manager")
    )

Ajanlar, gereksinimleri farklı rolleri arasında bölüştürür ve yazılım projesini planlayıp geliştirmek için iş birliği yapar. 

11. AgentScope

AgentScope, kontrol edilebilir ve gözlemlenebilir ajanlar ile çoklu ajan uygulamaları geliştirmek için bir Python framework’üdür. Hazır ajanlar, araçlar, hafıza, mesaj yönlendirme, akış, paralel araç çağrıları, iş akışları, izleme ve insan müdahalesi sunar. AgentScope Studio ise ajan yürütmesini incelemek ve görselleştirmek için kullanılabilir.

Aşağıdaki örnek, bir hesaplamayı tamamlamak için Python kodu yazıp çalıştırabilen bir ReAct ajanı oluşturur.

# pip install agentscope
# Set DASHSCOPE_API_KEY before running

import asyncio
import os

from agentscope.agent import ReActAgent
from agentscope.formatter import DashScopeChatFormatter
from agentscope.memory import InMemoryMemory
from agentscope.message import Msg
from agentscope.model import DashScopeChatModel
from agentscope.tool import Toolkit, execute_python_code


async def main():
    toolkit = Toolkit()
    toolkit.register_tool_function(execute_python_code)

    agent = ReActAgent(
        name="Nova",
        sys_prompt="You are a helpful Python assistant named Nova.",
        model=DashScopeChatModel(
            model_name="qwen-max",
            api_key=os.environ["DASHSCOPE_API_KEY"],
            stream=True,
        ),
        formatter=DashScopeChatFormatter(),
        toolkit=toolkit,
        memory=InMemoryMemory(),
    )

    await agent(
        Msg(
            name="user",
            content="Use Python to calculate the sum of numbers from 1 to 100.",
            role="user",
        )
    )


if __name__ == "__main__":
    asyncio.run(main())

Ajan, Python yürütme aracını çağırmaya karar verir, üretilen kodu çalıştırır ve sonucu kullanarak kullanıcıya yanıt verir.

12. CAMEL-AI

CAMEL-AI, ajanlar, çoklu ajan toplumları ve rol yapma simülasyonları geliştirmek için açık kaynak bir Python framework’üdür. Güçlü bir araştırma odağı vardır ve ajan iş birliği, araçlar, hafıza, geri getirme, veri üretimi ve dünya simülasyonu için bileşenler sunar. Ayrıca Ollama, vLLM ve SGLang gibi platformlar üzerinden bulut ve yerel modelleri destekler.

Aşağıdaki örnek, bir soruyu yanıtlamadan önce web’de arama yapabilen bir ajan oluşturur.

# pip install "camel-ai[web_tools]"
# Set OPENAI_API_KEY before running

from camel.agents import ChatAgent
from camel.models import ModelFactory
from camel.toolkits import SearchToolkit
from camel.types import ModelPlatformType, ModelType

model = ModelFactory.create(
    model_platform=ModelPlatformType.OPENAI,
    model_type=ModelType.GPT_5_5,
    model_config_dict={"temperature": 0.0},
)

agent = ChatAgent(
    system_message="You are a helpful AI research assistant.",
    model=model,
    tools=[SearchToolkit().search_duckduckgo],
)

response = agent.step(
    "What are the main uses of multi-agent AI systems?"
)

print(response.msgs[0].content)

Ajan, güncel bilgiye ihtiyaç duyduğunda DuckDuckGo aramasını kullanır ve ardından nihai yanıtı döndürür.

Veri ve RAG Ajan Framework’leri

Bu framework’ler, LLM’lerin ve ajanların yanıtlardan önce ilgili bağlamı getirebilmeleri için belgeler, veritabanları, API’ler ve diğer özel veri kaynaklarına bağlanmasına yardımcı olur.

13. LlamaIndex

LlamaIndex, özel veya alanına özgü veriler üzerinde bağlama duyarlı uygulamalar geliştirmek için bir Python framework’üdür. RAG, kurumsal arama ve belge asistanları gibi uygulamalar için bağlayıcılar, indeksler, getiriciler, sorgu motorları, ajanlar ve iş akışları sunar.

RAG uygulamaları geliştirmeye başladığımda favori framework’lerimden biriydi. Verileri yüklemeyi, indekslemeyi ve sorgulamayı son derece kolaylaştırır ve aynı uygulamayı LangChain ile geliştirmeye kıyasla kodunun daha basit ve kısa olduğunu sıkça görüyorum. Daha fazlası için LlamaIndex kursunu alabilirsiniz.

Aşağıdaki örnek, bir klasörden belgeleri yükler, aranabilir bir indeks oluşturur ve getirilen bağlamı kullanarak bir soruyu yanıtlar.

# pip install llama-index
# Set OPENAI_API_KEY before running

from llama_index.core import SimpleDirectoryReader, VectorStoreIndex

documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

query_engine = index.as_query_engine()
response = query_engine.query(
    "What are the main findings in these documents?"
)

print(response)

LlamaIndex, data klasörü içindeki dosyaları indeksler ve yanıtı üretmeden önce ilgili bilgileri getirir.

14. Haystack

Haystack, üretime hazır RAG hatları, anlamsal arama sistemleri, ajanlar ve veri odaklı yapay zeka uygulamaları geliştirmek için açık kaynaklı bir Python framework’üdür. Modüler hat yapısı, bilgilerin nasıl getirildiğini, isteme eklendiğini ve bir modele gönderildiğini açık biçimde kontrol etmenizi sağlar.

Önemli sorunlar yaşamadan RAG ve çoklu ajan uygulamaları geliştirmek için Haystack kullandım. Genel amaçlı bir framework olmasına karşın, LLM’leri belgelere, metne, arama sistemlerine ve diğer veri kaynaklarına bağlayan uygulamalar için özellikle kullanışlıdır.

Aşağıdaki örnek, birkaç belgeyi depolar, en ilgili olanı getirir ve bunu bir soruyu yanıtlamak için kullanır.

# pip install -U haystack-ai
# Set OPENAI_API_KEY before running

from haystack import Document, Pipeline
from haystack.components.builders import ChatPromptBuilder
from haystack.components.generators.chat import (
    OpenAIResponsesChatGenerator,
)
from haystack.components.retrievers import InMemoryBM25Retriever
from haystack.dataclasses import ChatMessage
from haystack.document_stores.in_memory import InMemoryDocumentStore

document_store = InMemoryDocumentStore()
document_store.write_documents([
    Document(content="The London AI event starts at 6:00 PM."),
    Document(content="The Berlin AI event starts at 7:00 PM."),
])

template = [
    ChatMessage.from_system(
        "Answer using the following documents:\n"
        "{% for doc in documents %}{{ doc.content }}{% endfor %}"
    ),
    ChatMessage.from_user("{{ question }}"),
]

pipeline = Pipeline()
pipeline.add_component(
    "retriever",
    InMemoryBM25Retriever(document_store),
)
pipeline.add_component(
    "prompt_builder",
    ChatPromptBuilder(template=template),
)
pipeline.add_component(
    "llm",
    OpenAIResponsesChatGenerator(model="gpt-5.5"),
)

pipeline.connect("retriever", "prompt_builder.documents")
pipeline.connect("prompt_builder", "llm")

question = "When does the London AI event start?"

result = pipeline.run({
    "retriever": {"query": question},
    "prompt_builder": {"question": question},
})

print(result["llm"]["replies"][0].text)

Haystack, eşleşen belgeyi getirir, isteme ekler ve temellendirilmiş bir yanıt üretmek için GPT-5.5’i kullanır.

Hafif ve Açık Model Framework’leri

Bu framework’ler, barındırılan veya yerelde çalışan açık modellerle ajanlar geliştirmek için daha basit soyutlamalar sunar.

15. Hugging Face smolagents

Hugging Face smolagents, az miktarda kodla ajanlar geliştirmek için hafif bir Python framework’üdür. CodeAgent, Python yazarak eylemler gerçekleştirirken ToolCallingAgent yapılandırılmış araç çağrılarını kullanır. Hugging Face modelleri, Inference Providers ve yerelde barındırılan açık kaynak modellerle özellikle iyi çalışır.

Aşağıdaki örnek bir web arama ajanı oluşturur ve araştırmayı ne zaman devredeceğine karar veren bir yönetici ajana verir.

# pip install -U "smolagents[toolkit]"
# Set HF_TOKEN before running

from smolagents import (
    CodeAgent,
    InferenceClientModel,
    ToolCallingAgent,
    WebSearchTool,
)

model = InferenceClientModel(
    model_id="Qwen/Qwen3-Next-80B-A3B-Thinking"
)

web_agent = ToolCallingAgent(
    tools=[WebSearchTool()],
    model=model,
    name="web_search_agent",
    description="Searches the web and returns useful information.",
)

manager_agent = CodeAgent(
    tools=[],
    model=model,
    managed_agents=[web_agent],
)

result = manager_agent.run(
    "Who created Hugging Face, and when was it founded?"
)

print(result)

Yönetici, güncel bilgiye ne zaman ihtiyaç duyduğuna karar verir, aramayı uzman web ajanına devreder ve ardından nihai yanıtı üretir.

Hızlı Framework Karşılaştırması

Aşağıdaki tablo, her framework’ün temel gücünü ve en uygun olduğu otonom yapay zeka uygulaması türünü karşılaştırır.

Son Düşünceler

Otonom yapay zekaya yeni başlıyorsanız, OpenAI Agents SDK, Google ADK veya Claude Agent SDK gibi resmi bir SDK ile başlamanızı öneririm. Kendi modelleri ve API’leriyle yakından çalıştıkları için kurulum genellikle basittir. Bir API anahtarı eklersiniz, biraz kredi yüklersiniz ve geliştirmeye başlarsınız.

Bu SDK’ları seviyorum; çünkü ajan oluşturmayı, araçları bağlamayı ve bir çalıştırma sırasında neler olduğunu incelemeyi kolaylaştırıyorlar. Sadece birkaç satır Python ile kullanışlı bir ajan, hatta küçük bir çoklu ajan sistemi bile geliştirebilirsiniz.

Daha fazla esnekliğe ihtiyaç duyduğumda genellikle LangChain veya LangGraph’a bakıyorum. Çok sayıda entegrasyona ihtiyaç duyduğumda LangChain, durum, döngüler ve daha uzun iş akışları üzerinde daha fazla kontrol içinse LangGraph işime yarıyor.

Farklı rollere sahip ajan ekipleri için CrewAI iyi bir seçenek. RAG, özel belgeler ve veri bağlantılı uygulamalar için LlamaIndex veya Haystack’i tercih ederim.

Son olarak, smolagents, hafif, basit ve açık ya da yerel modellerle kullanımı kolay bir şey istediğimde iyi bir tercih.

Önerim, projenize uyan en basit framework ile başlamanız. Küçük bir sürüm inşa edin, düzgünce test edin ve yalnızca gerçekten ihtiyaç duyduğunuzda daha fazla karmaşıklık ekleyin.