Belajar LangChain - Deployment & Production

#Pendahuluan

Di episode 19 kalian memasang LangSmith: tracing untuk observability, dataset dan evaluator untuk regression testing. Kualitas sudah terjaga, sekarang waktunya keluar dari laptop. Episode 20 ini membawa aplikasi ke produksi: menyajikan chain sebagai API dengan LangServe, mengetikkan kontrak input/output dengan Pydantic, streaming ke client, runtime LangGraph Platform untuk agent stateful, lalu operasionalnya — containerisasi, scaling, concurrency, auth endpoint, dan monitoring.

#LangServe: Mengubah Chain Menjadi REST API

LangServe adalah library yang mengubah chain LangChain menjadi REST API dengan beberapa baris. Dasar-dasarnya: sebuah aplikasi FastAPI, lalu add_routes untuk mendaftarkan chain pada sebuah path.

pip install "langserve[all]" langchain-openai

server.py

from fastapi import FastAPI
from langchain_openai import ChatOpenAI
from langserve import add_routes
 
app = FastAPI(title="API Ringkasan")
add_routes(
    app,
    ChatOpenAI(model="gpt-5-mini"),
    path="/ringkas",
)
 
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8080)

Jalankan dengan python server.py, dan LangServe otomatis menyediakan banyak endpoint untuk satu chain: /ringkas/invoke untuk panggilan tunggal, /ringkas/stream untuk streaming, /ringkas/batch untuk kumpulan input, serta /ringkas/playground untuk mencoba langsung dari browser. Satu chain, seluruh contract REST — tanpa menulis route satu per satu.

#Kontrak Input dan Output dengan Pydantic

API produksi tidak boleh menerima apa pun. Dengan Pydantic, add_routes menerima input_type dan output_type, sehingga request divalidasi sebelum masuk ke model dan response dijamin strukturnya.

schema.py

from pydantic import BaseModel
 
class Artikel(BaseModel):
    judul: str
    isi: str
 
class Ringkasan(BaseModel):
    ringkasan: str
    poin_penting: list[str]
 
add_routes(
    app,
    chain,
    path="/ringkas",
    input_type=Artikel,
    output_type=Ringkasan,
)

Dengan skema ini, dokumentasi API otomatis ter-generate di endpoint /docs FastAPI, dan request yang tidak sesuai langsung ditolak sebelum menyentuh model. Ini juga membuat client di sisi lain — web, mobile, atau CLI — tahu persis bentuk request dan response tanpa membaca kode sumber.

#Streaming ke Client

Pengalaman chat produksi butuh streaming. Client memanggil endpoint stream dengan POST, lalu membaca baris per baris selama koneksi terbuka.

client.py

import requests
 
with requests.post(
    "http://localhost:8080/ringkas/stream",
    json={"judul": "RAG", "isi": "Retrieval augmented generation..."},
    stream=True,
) as resp:
    for baris in resp.iter_lines():
        print(baris)

Endpoint /stream mengirim data sebagai Server-Sent Events, dan pengguna melihat token muncul bertahap. Pastikan proxy di depan aplikasi — misalnya Nginx atau load balancer — memiliki buffering yang dimatikan untuk path streaming, jika tidak, token akan menumpuk dan efek streaming hilang.

#LangGraph Platform untuk Agent Stateful

Untuk agent dengan state dan human-in-the-loop dari episode 13 dan 17, LangServe saja kurang pas. Di sinilah LangGraph Platform (atau server LangGraph self-hosted) berperan: runtime yang memahami graph, checkpoints, dan thread.

{
  "dependencies": ["."],
  "graphs": {
    "agent": "./src/agent.py:graph"
  },
  "env": ".env"
}

File langgraph.json mendeskripsikan entri graph dan dependency. Platform kemudian menyediakan endpoint seperti create run dalam sebuah thread_id, resume setelah interrupt, dan membaca state — semua dengan persistence bawaan dari checkpointing yang kalian pelajari di episode 7 dan 17. Deploy lewat CLI langgraph deploy ke cloud platform, atau jalankan sendiri di container.

#Containerisasi

Langkah selanjutnya adalah mengemas aplikasi agar berjalan di mana saja. Dockerfile multi-stage menjaga image tetap kecil dan aman.

FROM python:3.12-slim AS base
 
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
 
COPY . .
 
CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "8080"]

Build dan jalankan dengan docker build -t langchain-api . lalu docker run -p 8080:8080 langchain-api. Ini memudahkan konsistensi antara lokal, staging, dan produksi — hal yang tidak bisa dijamin jika tiap developer menjalankan aplikasi langsung di mesinnya.

#Scaling, Concurrency, dan Auth Endpoint

Chain LangServe bersifat stateless, sehingga scaling-nya horizontal: jalankan banyak instance di belakang load balancer dan distribusikan traffic. Untuk menaikkan concurrency di satu instance, tambahkan workers uvicorn dengan --workers atau jalankan aplikasi sebagai proses async.

uvicorn server:app --host 0.0.0.0 --port 8080 --workers 4

Di sisi keamanan, jangan pernah menyimpan API key provider di dalam image. Injeksikan lewat environment variable saat runtime — nilai seperti OPENAI_API_KEY dibaca dari environment, bukan di-hardcode. Untuk auth endpoint, taruh layer di depan: FastAPI dependency untuk token sederhana, atau OAuth/OIDC di ingress/API gateway untuk skala organisasi. Rule of thumb: chain boleh publik hanya jika memang disengaja publik.

#Monitoring Produksi

Observability episode 19 tidak berhenti di development — justru paling bernilai di produksi. Pertahankan tracing LangSmith aktif untuk inspeksi insiden, dan lengkapi dengan sinyal operasional:

• Health check: endpoint yang menandakan aplikasi siap menerima traffic.
• Metrics: jumlah request, latensi, error rate, dan token per menit.
• Alerting: notifikasi ketika error rate atau latensi melampaui ambang.
• Evaluasi berkala: jalankan regression test dataset dari episode 19 setiap rilis model atau prompt baru.

service: langchain-api
checks:
  health: /health
metrics:
  requests_per_sec: on
  latency_p95: on
  error_rate: on
  tokens_per_min: on
alerts:
  error_rate: "> 5% selama 5 menit"
  latency_p95: "> 8 detik selama 10 menit"

Kombinasi trace untuk diagnosis dan metric untuk deteksi membuat insiden produksi bisa ditemukan lebih cepat dan dianalisis sampai akar masalah.

#Penutup

Episode 20 membawa aplikasi LangChain ke produksi: LangServe untuk mengubah chain menjadi REST API lengkap dengan schema Pydantic dan streaming, LangGraph Platform untuk agent stateful, containerisasi dengan Docker, scaling horizontal dengan uvicorn workers, auth di depan endpoint, dan monitoring yang menyatukan trace, metric, serta evaluasi berkala.

Inti yang harus dibawa pulang:

• add_routes mengubah chain menjadi API dengan endpoint invoke, stream, batch, dan playground.
• Skema Pydantic di input_type dan output_type menegakkan kontrak API.
• LangGraph Platform menangani agent stateful, thread, dan human-in-the-loop.
• Containerisasi membuat perilaku konsisten lintas environment.
• API key provider diinjeksi via env saat runtime, auth ditaruh di depan endpoint.

Di episode 21 berikutnya kita melihat ke depan: Fitur Modern 2026 & Roadmap — arsitektur v1.x, content-block streaming v2/v3, Context Hub, Harness Profiles, Deep Agents v0.5+, integrasi MCP, dan arah pengembangan LangChain. Sampai jumpa!