15 Framework Python Teratas untuk Membangun Aplikasi AI Agentic yang Lengkap

Membangun aplikasi AI agentic kini jauh lebih mudah dibandingkan beberapa tahun lalu. Alih-alih membuat loop agen, integrasi tool, memori, retrieval, dan orkestrasi dari nol, developer dapat menggunakan framework Python yang sudah menyediakan sebagian besar komponen tersebut.

Saya telah menggunakan banyak framework dalam artikel ini untuk membangun aplikasi RAG, agen otonom, sistem multi-agen, dan alat AI yang dapat dideploy.

Saya sering menggunakan LangChain untuk alur kerja agen yang fleksibel, LlamaIndex dan Haystack untuk aplikasi yang terhubung data, serta OpenAI Agents SDK atau Google ADK saat saya menginginkan integrasi lebih cepat dengan model penyedia.

Beberapa framework ini telah berkembang pesat sehingga membangun solusi kustom sering kali tidak diperlukan. Dengan kunci API, sejumlah kredit model, dan framework yang tepat, Anda dapat membuat agen, menghubungkannya ke tool atau data privat, mengujinya, dan mendistribusikannya melalui API atau antarmuka pengguna.

Artikel ini membandingkan 15 framework Python dalam lima kategori: framework agen serbaguna, SDK agen resmi, framework orkestrasi multi-agen, framework data dan RAG, serta framework ringan berbasis model terbuka.

Setiap bagian juga menyertakan contoh Python singkat yang dapat Anda salin, tempel, dan uji untuk cepat memahami cara kerja framework tersebut.

Framework Agen Serbaguna

Framework ini menyediakan blok bangunan luas untuk membuat agen, menghubungkan tool, mengelola state, dan mengendalikan alur kerja multi-langkah.

1. LangChain

Bagi banyak developer, pengembangan aplikasi LLM modern dimulai dengan LangChain, sebuah framework Python open-source yang dirancang untuk menghubungkan model bahasa dengan data eksternal, tool, API, dan logika aplikasi. Framework ini menjadi salah satu yang pertama banyak diadopsi untuk menggunakan OpenAI API bersama situs web, dokumen, basis data vektor, dan sumber data lain guna membangun aplikasi yang lebih kontekstual.

Kini, LangChain telah berkembang menjadi ekosistem lengkap untuk membangun aplikasi AI agentic end-to-end, termasuk sistem RAG, agen yang menggunakan tool, workflow, integrasi, pemantauan, dan evaluasi. Saya sarankan melihat track AI Engineering with LangChain untuk mempelajari lebih lanjut.

Contoh berikut membuat agen LangChain sederhana yang dapat menggunakan tool pencarian dokumentasi untuk menemukan informasi relevan sebelum menjawab pertanyaan.

# 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

Sementara LangChain memudahkan pembuatan agen dan tool, LangGraph memberikan kontrol lebih atas cara agen tersebut beroperasi. Framework ini memungkinkan developer menyusun aplikasi sebagai graf langkah-langkah yang saling terhubung, sehingga lebih mudah mengendalikan loop, pemanggilan tool, state bersama, persetujuan manusia, dan alur kerja multi-agen.

Saya merasa ini sangat berguna saat membangun agen otonom yang harus berulang kali memutuskan apa yang harus dilakukan, memilih tool yang tepat, memeriksa hasilnya, dan melanjutkan hingga tugas selesai. LangGraph juga mendukung persistensi, streaming, checkpoint, dan pemulihan untuk aplikasi yang berjalan lebih lama. Tutorial LangGraph kami memberikan detail lebih lanjut.

Contoh berikut membuat agen yang dapat berulang kali memanggil tool kalkulator hingga memiliki informasi yang cukup untuk menjawab:

# 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)

Graf mengirim permintaan ke model, menjalankan tool yang diperlukan, dan kembali ke model hingga menghasilkan jawaban akhir.

3. Agno

Agno adalah framework Python untuk membangun agen, tim multi-agen, dan workflow terstruktur. Framework ini juga menyertakan AgentOS, yang membantu developer mengekspos agen melalui API, menyimpan sesi dan jejak, serta mengelolanya sebagai aplikasi produksi. Karena dapat berjalan di infrastruktur Anda sendiri, organisasi memiliki kontrol lebih besar atas data dan keamanannya.

Contoh berikut membuat agen riset yang dapat menelusuri web sebelum menghasilkan respons ringkas.

# 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,
)

Agen menggunakan tool pencarian untuk menemukan informasi terkini dan men-stream ringkasan singkat kepada pengguna.

4. Pydantic AI

Pydantic AI adalah framework Python-native dari tim di balik Pydantic untuk membangun agen dan aplikasi AI generatif. Pengalaman penggunaannya mirip dengan bekerja menggunakan model Pydantic atau FastAPI karena agen, tool, dependensi, dan output didefinisikan menggunakan fungsi Python standar, type hint, decorator, dan kelas BaseModel. Framework ini kemudian menggunakan validasi Pydantic untuk menjaga argumen tool dan output model tetap terstruktur dan andal.

Saya dapat merekomendasikan tutorial Pydantic AI untuk mempelajari lebih lanjut tentang framework ini.

Contoh berikut membuat agen yang mengembalikan rencana artikel tervalidasi sebagai model Pydantic.

# 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)

Agen menghasilkan objek ArticlePlan dan memvalidasi bahwa setiap field sesuai dengan tipe dan aturan Python yang diperlukan sebelum mengembalikannya.

SDK Agen Resmi

SDK agen resmi dipelihara oleh penyedia AI dan biasanya menawarkan integrasi paling sederhana dengan model, API, tool, sistem deployment, dan platform observabilitas mereka.

5. OpenAI Agents SDK

OpenAI Agents SDK adalah framework ringan berfokus Python untuk membangun aplikasi agen tunggal dan multi-agen. Framework ini menyediakan loop agen bawaan, function tools, handoff, guardrail, sesi, persetujuan manusia, dan tracing tanpa menambahkan terlalu banyak abstraksi.

Saya senang menggunakan OpenAI Agents SDK karena sederhana, cepat diintegrasikan, dan mudah dipahami. Saya telah membangun banyak aplikasi dengannya tanpa masalah besar. SDK ini juga otomatis membuat trace yang dapat dilihat di OpenAI Dashboard, sehingga mudah untuk memeriksa respons model, pemanggilan tool, handoff, dan alur eksekusi lengkap.

Contoh berikut membuat agen sejarah yang dapat memanggil fungsi Python untuk mengambil fakta sejarah yang mengejutkan.

# 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 menjalankan agen, memanggil tool sejarah saat diperlukan, mengembalikan hasilnya ke model, dan menghasilkan respons akhir. Seluruh proses juga dapat diperiksa melalui penampil trace.

7. Google Agent Development Kit

Agent Development Kit milik Google, atau ADK, adalah framework open-source untuk membangun, mengevaluasi, dan mendistribusikan agen individual, asisten yang menggunakan tool, workflow berbasis graf, dan sistem multi-agen. Framework ini bekerja sangat baik dengan model Gemini, sekaligus mendukung penyedia model lainnya.

ADK menjadi salah satu framework favorit saya karena sederhana dan bekerja secara natural dengan Gemini.

Saya telah menggunakannya untuk membangun beberapa aplikasi tanpa masalah besar. Meski saya masih merasa OpenAI Agents SDK lebih mudah diintegrasikan dan lebih fleksibel dari sisi kontrol dan fitur bawaan, ADK adalah alternatif kuat dan sangat kompetitif untuk aplikasi berbasis Gemini.

Contoh berikut membuat asisten acara yang dapat memanggil fungsi Python untuk mengambil waktu mulai sebuah acara.

# 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],
)

Agen menggunakan fungsi tersebut sebagai tool setiap kali perlu mengambil waktu acara untuk kota tertentu.

8. Claude Agent SDK

Claude Agent SDK adalah framework Python dan TypeScript dari Anthropic untuk membangun agen otonom menggunakan loop agen, tool, dan manajemen konteks yang sama yang mendukung Claude Code. SDK ini sangat berguna untuk agen yang perlu membaca file, mengedit kode, menjalankan perintah, terhubung ke tool MCP, dan menyelesaikan tugas yang lebih panjang.

Anthropic, OpenAI, dan Google mengintegrasikan model mereka dengan erat melalui framework agen masing-masing, sehingga tool, sesi, tracing, dan fitur lanjutan lainnya cepat disetel.

Namun, Claude Agent SDK dirancang khusus untuk Claude alih-alih model open-source atau model yang dihosting secara lokal secara umum. Anda dapat mempelajari lebih lanjut di tutorial Claude Agent SDK kami.

Contoh berikut membuat agen pemrograman yang meninjau file Python, mengidentifikasi bug, dan memperbaikinya secara otomatis.

# 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 menjalankan loop agen sementara Claude membaca file, memilih tool yang diperlukan, mengedit kode, dan men-stream progresnya hingga tugas selesai.

Framework Orkestrasi Multi-Agen

Framework multi-agen mengoordinasikan beberapa agen spesialis, dengan setiap agen diberi peran, tujuan, set tool, atau tahap tertentu dalam alur kerja yang lebih besar. 

9. CrewAI

CrewAI adalah framework Python populer untuk membangun tim multi-agen. Developer dapat membuat agen dengan peran, tujuan, dan tugas berbeda, lalu menggabungkannya menjadi sebuah kru yang bekerja bersama secara otonom. Tugas dapat berjalan secara berurutan atau melalui proses hierarkis di mana seorang manajer mengoordinasikan dan mendelegasikan pekerjaan kepada agen yang paling sesuai.

Contoh Python berikut membuat peneliti dan penulis yang bekerja sama menghasilkan laporan singkat.

# 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)

Peneliti menyelesaikan tugas pertama, dan penulis menggunakan keluarannya sebagai konteks untuk membuat laporan akhir.

10. MetaGPT

MetaGPT adalah framework multi-agen yang memodelkan sebuah perusahaan perangkat lunak menggunakan agen spesialis seperti product manager, arsitek, project manager, dan engineer. Agen-agen ini mengikuti prosedur operasi terstruktur untuk mengubah kebutuhan singkat menjadi rencana, desain teknis, dokumentasi, dan kode yang berfungsi. 

Contoh berikut membuat sebuah tim perangkat lunak dan memintanya membangun task manager sederhana berbasis command-line.

# 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")
    )

Para agen membagi kebutuhan sesuai peran mereka yang berbeda dan berkolaborasi untuk merencanakan serta mengembangkan proyek perangkat lunak. 

11. AgentScope

AgentScope adalah framework Python untuk membangun agen dan aplikasi multi-agen yang dapat dikendalikan dan dapat diobservasi. Framework ini menyediakan agen siap pakai, tool, memori, perutean pesan, streaming, pemanggilan tool paralel, workflow, tracing, dan intervensi manusia. AgentScope Studio juga dapat digunakan untuk memeriksa dan memvisualisasikan eksekusi agen.

Contoh berikut membuat agen ReAct yang dapat menulis dan mengeksekusi kode Python untuk menyelesaikan perhitungan.

# 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())

Agen memutuskan untuk memanggil tool eksekusi Python, menjalankan kode yang dihasilkan, dan menggunakan hasilnya untuk menjawab pengguna.

12. CAMEL-AI

CAMEL-AI adalah framework Python open-source untuk membangun agen, masyarakat multi-agen, dan simulasi role-playing. Framework ini memiliki fokus riset yang kuat dan menyediakan komponen untuk kolaborasi agen, tool, memori, retrieval, pembuatan data, dan simulasi dunia. Framework ini juga mendukung model cloud dan model yang dihosting secara lokal melalui platform seperti Ollama, vLLM, dan SGLang.

Contoh berikut membuat agen yang dapat menelusuri web sebelum menjawab pertanyaan.

# 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)

Agen menggunakan pencarian DuckDuckGo saat membutuhkan informasi terkini dan kemudian mengembalikan jawaban akhir.

Framework Agen Data dan RAG

Framework ini membantu menghubungkan LLM dan agen ke dokumen, basis data, API, dan sumber data privat lainnya sehingga dapat mengambil konteks relevan sebelum merespons.

13. LlamaIndex

LlamaIndex adalah framework Python untuk membangun aplikasi yang sadar konteks di atas data privat atau spesifik domain. Framework ini menyediakan konektor, indeks, retriever, mesin kueri, agen, dan workflow untuk aplikasi seperti RAG, pencarian enterprise, dan asisten dokumen.

LlamaIndex adalah salah satu framework favorit saya saat mulai membangun aplikasi RAG. Framework ini membuat proses memuat, mengindeks, dan mengkueri data menjadi sangat mudah, dan saya sering menemukan kodenya lebih sederhana dan lebih pendek dibandingkan membangun aplikasi yang sama dengan LangChain. Anda dapat mengikuti kursus LlamaIndex untuk mempelajari lebih lanjut.

Contoh berikut memuat dokumen dari sebuah folder, membuat indeks yang dapat dicari, dan menjawab pertanyaan menggunakan konteks yang diambil.

# 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 mengindeks file di dalam folder data dan mengambil informasi relevan sebelum menghasilkan jawaban.

14. Haystack

Haystack adalah framework Python open-source untuk membangun pipeline RAG siap produksi, sistem pencarian semantik, agen, dan aplikasi AI berfokus data. Struktur pipeline modularnya memberikan kontrol jelas atas bagaimana informasi diambil, ditambahkan ke prompt, dan dikirim ke model.

Saya telah menggunakan Haystack untuk membangun aplikasi RAG dan multi-agen tanpa masalah besar. Meski merupakan framework serbaguna, Haystack sangat berguna untuk aplikasi yang menghubungkan LLM ke dokumen, teks, sistem pencarian, dan sumber data lainnya.

Contoh berikut menyimpan beberapa dokumen, mengambil dokumen yang paling relevan, dan menggunakannya untuk menjawab pertanyaan.

# 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 mengambil dokumen yang cocok, menambahkannya ke prompt, dan menggunakan GPT-5.5 untuk menghasilkan jawaban yang berlandaskan konteks.

Framework Ringan dan Berbasis Model Terbuka

Framework ini menyediakan abstraksi yang lebih sederhana untuk membangun agen dengan model terbuka yang dihosting atau berjalan secara lokal.

15. Hugging Face smolagents

Hugging Face smolagents adalah framework Python ringan untuk membangun agen dengan hanya sedikit kode. CodeAgent melakukan aksi dengan menulis Python, sementara ToolCallingAgent menggunakan pemanggilan tool terstruktur. Framework ini bekerja sangat baik dengan model Hugging Face, Inference Providers, dan model open-source yang dihosting secara lokal.

Contoh berikut membuat agen penelusuran web dan memberikannya kepada agen manajer yang memutuskan kapan harus mendelegasikan riset.

# 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)

Manajer memutuskan kapan membutuhkan informasi terkini, mendelegasikan pencarian kepada agen web spesialis, lalu menghasilkan jawaban akhir.

Perbandingan Cepat Framework

Tabel di bawah ini membandingkan kekuatan utama setiap framework dan jenis aplikasi AI agentic yang paling sesuai.

Pemikiran Akhir

Jika Anda baru mulai dengan AI agentic, saya akan memulai dengan SDK resmi seperti OpenAI Agents SDK, Google ADK, atau Claude Agent SDK. Framework ini bekerja erat dengan model dan API mereka sendiri, sehingga penyiapannya biasanya sederhana. Anda menambahkan kunci API, mengisi kredit, dan mulai membangun.

Saya menyukai SDK ini karena memudahkan membuat agen, menghubungkan tool, dan memeriksa apa yang terjadi selama proses berjalan. Hanya dengan beberapa baris Python, Anda dapat membangun agen yang berguna atau bahkan sistem multi-agen kecil.

Saat saya membutuhkan fleksibilitas lebih, saya biasanya melihat LangChain atau LangGraph. LangChain berguna ketika saya memerlukan banyak integrasi, sementara LangGraph memberi saya lebih banyak kontrol atas state, loop, dan workflow yang lebih panjang.

Untuk tim agen dengan peran berbeda, CrewAI adalah pilihan yang baik. Untuk RAG, dokumen privat, dan aplikasi yang terhubung data, saya akan memilih LlamaIndex atau Haystack.

Terakhir, smolagents adalah pilihan yang baik saat saya menginginkan sesuatu yang ringan, sederhana, dan mudah digunakan dengan model terbuka atau lokal.

Saran saya adalah mulai dengan framework paling sederhana yang sesuai dengan proyek Anda. Bangun versi kecil, uji dengan baik, dan hanya tambahkan kompleksitas saat Anda benar-benar membutuhkannya.