LangChain vs Membangun Orkestrasi LLM Sendiri: Kapan Menggunakan Masing-Masing

Saya telah membangun aplikasi LLM dengan dua cara: menggunakan LangChain (dan LangGraph) sebagai lapisan orkestrasi, dan membangun orkestrasi kustom dari awal dengan panggilan API langsung. Aplikasi AI Gymbro fitness saya dimulai dengan LangChain dan ditulis ulang sebagai orkestrasi kustom enam minggu kemudian.

Apa Sebenarnya LangChain (dan Bukan)

LangChain adalah framework Python/JavaScript yang menyediakan abstraksi untuk pola LLM umum: chain (urutan panggilan LLM), agent (LLM + alat + loop), retrieval (integrasi vector store), dan memory (manajemen riwayat percakapan). Proposi nilai: LangChain memberi Anda antarmuka terpadu di berbagai provider LLM.

Pajak Abstraksi

Setiap lapisan abstraksi menambahkan jarak debugging antara kode Anda dan API yang mendasarinya. Ketika chain LangChain gagal, Anda mendapatkan stack trace melalui 5 lapisan internal LangChain sebelum melihat error API yang sebenarnya. Saya menghabiskan 3 jam men-debug SequentialChain LangChain yang secara diam-diam menghapus output.

Di Mana LangChain Benar-Benar Menghemat Waktu

LangChain bernilai untuk tiga kasus penggunaan: prototyping cepat (Anda bisa mendapatkan pipeline RAG yang berjalan dalam 50 baris Python), dukungan multi-provider (jika Anda benar-benar perlu beralih antara OpenAI, Anthropic, dan Bedrock tanpa perubahan kode), dan alur kerja agent stateful yang kompleks via LangGraph.

LangChain vs Custom: Decision Framework

  Start
    │
    ▼
  Do you need to switch LLM providers often?
    ├── Yes → LangChain (unified interface)
    └── No  → Continue...
                │
                ▼
  Is your workflow > 4 states with branching?
    ├── Yes → LangGraph
    └── No  → Continue...
                │
                ▼
  Do you have > 5 integrations (vector stores,
  document loaders, custom tools)?
    ├── Yes → LangChain ecosystem
    └── No  → Continue...
                │
                ▼
  How many LLM calls per user request?
    ├── 1-3  → Custom orchestration (simpler, faster)
    └── 4+   → Evaluate LangGraph
                │
                ▼
  Do you need sub-200ms latency?
    ├── Yes → Custom (no abstraction overhead)
    └── No  → Either works

  Verdict:
  Simple app (1-3 calls, < 5 integrations) → Custom
  Complex agent (many states, multi-provider) → LangChain/LangGraph

Kapan Membangun Orkestrasi Kustom

Bangun orkestrasi kustom ketika: alur kerja Anda sederhana (1-3 panggilan LLM per permintaan pengguna); Anda membutuhkan kontrol tepat atas penggunaan token dan caching; Anda membutuhkan output streaming dengan perilaku UI tertentu; atau tim Anda lebih nyaman men-debug JavaScript/Python daripada internal framework.

LangGraph untuk Alur Kerja yang Kompleks

LangGraph layak dipisahkan dari LangChain proper. Model alur kerja berbasis grafik (node adalah aksi, edge adalah transisi state) sangat berguna untuk alur kerja agent multi-langkah yang kompleks dengan jalur percabangan, eksekusi kondisional, dan state yang perlu bertahan di berbagai giliran.

# LangChain RAG — 50 lines, fast to prototype
from langchain_anthropic import ChatAnthropic
from langchain_community.vectorstores import PGVector
from langchain.chains import RetrievalQA

llm = ChatAnthropic(model="claude-3-5-haiku-20241022")
vectorstore = PGVector.from_existing_index(connection_string=DB_URL)
chain = RetrievalQA.from_chain_type(llm=llm, retriever=vectorstore.as_retriever())
result = chain.invoke({"query": "What exercises target the lats?"})

# Custom RAG — 200 lines, full control
async def custom_rag(query: str) -> str:
    # 1. HyDE — generate hypothetical answer for better embedding
    hyp_answer = await llm.generate(f"Write a brief answer to: {query}")
    embedding = await embed(hyp_answer)

    # 2. Vector search with metadata filter
    chunks = await db.search(embedding, filter={"type": "exercise"}, limit=20)

    # 3. Rerank
    reranked = await cohere_rerank(query, chunks, top_n=5)

    # 4. Generate with precise prompt + caching
    context = "

".join(c.content for c in reranked)
    return await llm.generate(
        system=CACHED_SYSTEM_PROMPT,  # prompt caching
        user=f"Context:
{context}

Question: {query}"
    )
# Custom is more work but: 30% fewer tokens, 25% lower latency, easier to debug

Kerangka Keputusan

Gunakan LangChain/LangGraph jika: Anda membangun aplikasi RAG dan menginginkan iterasi cepat pada strategi retrieval; Anda membutuhkan dukungan multi-provider; Anda membangun alur kerja agent stateful yang kompleks; atau tim Anda sudah mengenal LangChain. Lewati LangChain jika: alur kerja Anda memiliki kurang dari 3 panggilan LLM; Anda membutuhkan kontrol token yang tepat; atau Anda membutuhkan kustomisasi streaming yang mendalam.

Apa yang Akan Saya Lakukan Sekarang Jika Memulai dari Awal

Untuk proyek LLM baru di 2025, saya akan mulai dengan panggilan API langsung menggunakan SDK resmi Anthropic atau OpenAI (keduanya sangat baik), tambahkan LangSmith untuk observabilitas (ini berfungsi tanpa LangChain), dan perkenalkan LangGraph hanya jika kompleksitas alur kerja benar-benar memerlukannya.

Faktor Ekosistem

Satu keunggulan nyata LangChain di 2025 adalah ekosistemnya: 600+ integrasi (vector store, document loader, alat), komunitas besar, dan LangSmith untuk observabilitas. Jika Anda perlu mengintegrasikan dengan database vektor tertentu, konektor bawaan LangChain menghemat waktu nyata.

Sumber & Bacaan Lanjutan

Artikel Terkait

• Pelajaran Produksi Pipeline RAG
• Otomatisasi Alur Kerja AI Agent di 2025