Membangun AI Coding Agent dengan LangGraph + FastAPI (Panduan Lengkap 2026)

Level: Menengah

Estimasi baca: 15 menit

Stack: Python, LangGraph, FastAPI, OpenAI API

1) Introduction — What & Why

Kalau kamu ngikutin tren developer di 2026, satu pola kelihatan jelas: developer bukan lagi cuma nulis kode manual, tapi mengorkestrasi agent. Di GitHub Trending, project bertema AI agent, orchestration, dan observability naik cepat. Di X (Twitter), diskusi tentang “AI coding workflow”, “agentic development”, dan “spec-first coding agents” juga konsisten ramai. Di DEV Community pun artikel tentang AI agent, tooling, dan observability terus muncul.

Pertanyaannya: kenapa AI coding agent jadi penting?

Karena kebutuhan software engineering sekarang bukan sekadar “generate code”, tapi:

• memahami konteks project,
• melakukan langkah berurutan (plan → implement → verifikasi),
• menjaga state (apa yang sudah dicoba, error apa yang muncul),
• dan tetap aman serta bisa diaudit.

Di sinilah LangGraph relevan. Dibanding loop sederhana “prompt → response”, LangGraph kasih kamu struktur graph, state yang persist, serta pola human-in-the-loop. Artinya, agent kamu bisa lebih stabil untuk workflow coding nyata.

Dalam tutorial ini, kita akan membangun AI Coding Agent API yang bisa:

1. menerima task coding,
2. membuat rencana,
3. mengeksekusi kode Python secara aman terbatas,
4. merangkum hasil,
5. menyimpan histori per sesi.

Output akhir bisa kamu pakai sebagai fondasi internal coding assistant tim kamu.

---

2) Prerequisites — Sebelum Mulai

Pastikan kamu sudah punya:

• Python 3.11+
• Dasar FastAPI
• API key model LLM (contoh: OpenAI)
• Pemahaman dasar tentang async Python

Install dependency:

python -m venv .venv
source .venv/bin/activate  # Windows: .venv\Scripts\activate

pip install -U fastapi uvicorn pydantic langgraph langchain-openai python-dotenv

Buat file .env:

OPENAI_API_KEY=sk-xxxx
MODEL_NAME=gpt-4.1-mini

Kalau kamu pakai provider lain, pola arsitekturnya tetap sama. Tinggal ganti adapter model di layer LLM.

---

3) Core Concepts — Fondasi yang Wajib Dipahami

Sebelum ngoding, pahami 4 konsep inti.

a) Agent State

Bayangin agent seperti chef di dapur profesional. Dia nggak cuma butuh resep terakhir, tapi juga:

• bahan yang sudah dipakai,
• langkah yang sudah dieksekusi,
• error yang pernah muncul,
• keputusan berikutnya.

Semua itu adalah state.

b) Node dan Edge (Graph Thinking)

LangGraph bekerja seperti peta metro:

• Node = stasiun kerja (planner, coder, reviewer, executor)
• Edge = jalur perpindahan antar tahap

Keuntungannya: alur lebih eksplisit, mudah debug, mudah ditambah aturan.

c) Tool Calling

LLM tidak boleh bebas ngakses sistem. Kita kasih “alat” terbatas, misalnya:

• menjalankan potongan Python di sandbox mini,
• membaca hasil eksekusi,
• mengembalikan output terstruktur.

d) Guardrails

Coding agent tanpa guardrails = risiko tinggi. Minimal perlu:

• batas waktu eksekusi,
• whitelist builtins,
• blok import berbahaya,
• validasi input/output.

---

4) Architecture / Diagram

Arsitektur sederhana kita seperti ini:

Client (Web / CLI)
      |
      v
 FastAPI /agent/run
      |
      v
+-------------------------+
| LangGraph Runtime       |
|-------------------------|
| 1) Planner Node         |
| 2) Coder Node           |
| 3) Python Tool Node     |
| 4) Reviewer Node        |
+-------------------------+
      |
      v
 Session Memory (in-memory / DB nanti)

Alur:

1. User kirim objective.
2. Planner pecah task jadi langkah.
3. Coder generate snippet kode.
4. Tool node eksekusi snippet dengan sandbox terbatas.
5. Reviewer merangkum hasil + next action.
6. Semua langkah disimpan dalam state sesi.

---

5) Step-by-Step Implementation (Runnable)

Di bagian ini kita bikin aplikasi lengkap yang bisa langsung jalan.

Struktur file

coding-agent/
  app.py
  .env

Kode lengkap app.py

import os
import io
import contextlib
from typing import TypedDict, List, Dict, Any

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field
from dotenv import load_dotenv

from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI

# -------------------------
# Setup
# -------------------------
load_dotenv()
MODEL_NAME = os.getenv("MODEL_NAME", "gpt-4.1-mini")
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")

if not OPENAI_API_KEY:
    raise RuntimeError("OPENAI_API_KEY tidak ditemukan di environment")

llm = ChatOpenAI(model=MODEL_NAME, temperature=0)
app = FastAPI(title="AI Coding Agent API", version="1.0.0")

# Session memory sederhana (demo)
SESSION_STORE: Dict[str, Dict[str, Any]] = {}


# -------------------------
# State definitions
# -------------------------
class AgentState(TypedDict, total=False):
    session_id: str
    user_goal: str
    plan: str
    code: str
    execution_output: str
    execution_error: str
    final_summary: str
    trace: List[str]


class RunRequest(BaseModel):
    session_id: str = Field(..., min_length=1)
    goal: str = Field(..., min_length=5)


class RunResponse(BaseModel):
    session_id: str
    plan: str
    code: str
    execution_output: str
    execution_error: str
    final_summary: str
    trace: List[str]


# -------------------------
# Safe python executor
# -------------------------
def safe_exec_python(code: str, timeout_hint_seconds: int = 3) -> Dict[str, str]:
    """Menjalankan kode Python dengan guardrail minimal.
    NOTE: untuk production, gunakan sandbox terpisah (container/VM)."""
    blocked_keywords = [
        "import os", "import sys", "import subprocess", "import socket",
        "open(", "__import__", "eval(", "exec(", "from os", "from subprocess"
    ]

    lowered = code.lower()
    for bad in blocked_keywords:
        if bad in lowered:
            return {
                "stdout": "",
                "error": f"Blocked by guardrail: terdeteksi keyword terlarang -> {bad}"
            }

    safe_builtins = {
        "print": print,
        "len": len,
        "range": range,
        "sum": sum,
        "min": min,
        "max": max,
        "enumerate": enumerate,
        "sorted": sorted,
        "str": str,
        "int": int,
        "float": float,
        "list": list,
        "dict": dict,
        "set": set,
        "tuple": tuple,
    }

    stdout_buffer = io.StringIO()
    local_env: Dict[str, Any] = {}

    try:
        with contextlib.redirect_stdout(stdout_buffer):
            exec(code, {"__builtins__": safe_builtins}, local_env)
        return {"stdout": stdout_buffer.getvalue(), "error": ""}
    except Exception as e:
        return {"stdout": stdout_buffer.getvalue(), "error": f"{type(e).__name__}: {e}"}


# -------------------------
# Graph nodes
# -------------------------
def planner_node(state: AgentState) -> AgentState:
    prompt = f"""
Kamu adalah software planner.
Buat rencana 3-5 langkah untuk menyelesaikan goal berikut:
{state['user_goal']}

Format ringkas bullet points.
"""
    plan = llm.invoke(prompt).content
    trace = state.get("trace", []) + ["planner_node selesai"]
    return {"plan": plan, "trace": trace}


def coder_node(state: AgentState) -> AgentState:
    prompt = f"""
Kamu adalah Python engineer.
Berdasarkan goal dan plan berikut, tulis SATU snippet Python runnable.

Goal:
{state['user_goal']}

Plan:
{state['plan']}

Batasan:
- Jangan import modul eksternal.
- Harus ada error handling (try/except).
- Harus print hasil final.

Kembalikan HANYA kode Python, tanpa markdown fence.
"""
    code = llm.invoke(prompt).content.strip()
    trace = state.get("trace", []) + ["coder_node selesai"]
    return {"code": code, "trace": trace}


def tool_exec_node(state: AgentState) -> AgentState:
    result = safe_exec_python(state.get("code", ""))
    trace = state.get("trace", []) + ["tool_exec_node selesai"]
    return {
        "execution_output": result.get("stdout", ""),
        "execution_error": result.get("error", ""),
        "trace": trace,
    }


def reviewer_node(state: AgentState) -> AgentState:
    prompt = f"""
Kamu adalah reviewer teknis.
Ringkas hasil eksekusi kode berikut dalam bahasa Indonesia.

Goal:
{state['user_goal']}

Output:
{state.get('execution_output', '')}

Error:
{state.get('execution_error', '')}

Berikan:
1) Status (Berhasil/Gagal)
2) Analisis singkat
3) Saran perbaikan
"""
    final_summary = llm.invoke(prompt).content
    trace = state.get("trace", []) + ["reviewer_node selesai"]
    return {"final_summary": final_summary, "trace": trace}


# -------------------------
# Build graph
# -------------------------
builder = StateGraph(AgentState)
builder.add_node("planner", planner_node)
builder.add_node("coder", coder_node)
builder.add_node("executor", tool_exec_node)
builder.add_node("reviewer", reviewer_node)

builder.set_entry_point("planner")
builder.add_edge("planner", "coder")
builder.add_edge("coder", "executor")
builder.add_edge("executor", "reviewer")
builder.add_edge("reviewer", END)

graph = builder.compile()


# -------------------------
# API endpoints
# -------------------------
@app.post("/agent/run", response_model=RunResponse)
def run_agent(req: RunRequest):
    try:
        initial_state: AgentState = {
            "session_id": req.session_id,
            "user_goal": req.goal,
            "trace": ["request diterima"]
        }

        final_state = graph.invoke(initial_state)

        # Simpan session
        SESSION_STORE[req.session_id] = final_state

        return RunResponse(
            session_id=req.session_id,
            plan=final_state.get("plan", ""),
            code=final_state.get("code", ""),
            execution_output=final_state.get("execution_output", ""),
            execution_error=final_state.get("execution_error", ""),
            final_summary=final_state.get("final_summary", ""),
            trace=final_state.get("trace", []),
        )

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Internal error: {e}")


@app.get("/agent/session/{session_id}")
def get_session(session_id: str):
    data = SESSION_STORE.get(session_id)
    if not data:
        raise HTTPException(status_code=404, detail="Session tidak ditemukan")
    return data

Menjalankan server

uvicorn app:app --reload --port 8000

Test endpoint

curl -X POST http://127.0.0.1:8000/agent/run \
  -H 'Content-Type: application/json' \
  -d '{
    "session_id": "demo-001",
    "goal": "Buat program Python untuk menghitung rata-rata nilai siswa dan tampilkan status lulus jika >= 75"
  }'

Kalau berhasil, kamu akan dapat:

• rencana langkah,
• kode yang dihasilkan,
• output eksekusi,
• ringkasan reviewer.

---

6) Best Practices — Tips Industri

1. Pakai spec-first, bukan prompt random

Sebelum generate code, paksa planner bikin rencana dulu. Ini menurunkan halusinasi dan bikin output lebih konsisten.

2. Pisahkan role tiap node

Planner jangan sekalian ngoding. Coder jangan sekalian menilai kualitas. Separation of concern bikin debugging jauh lebih gampang.

3. Simpan trace dan artefak

Simpan prompt, output node, dan error per langkah. Ini penting untuk audit, observability, dan postmortem.

4. Terapkan policy tool yang ketat

Jangan kasih akses file system/network tanpa alasan bisnis jelas. Default posture: deny by default.

5. Evaluasi dengan test case nyata

Bukan cuma “apakah model menjawab”, tapi “apakah solusi lolos skenario edge case?”

---

7) Common Mistakes — Kesalahan yang Sering Terjadi

Mistake #1: Menganggap agent = chatbot

Chatbot bisa bagus di demo, tapi gagal di workflow panjang. Agent butuh state, kontrol alur, dan mekanisme retry.

Mistake #2: Tidak membatasi tool execution

Kalau kamu memberi exec bebas tanpa guardrail, ini bukan fitur — ini insiden keamanan yang menunggu waktu.

Mistake #3: Tidak ada fallback saat LLM output jelek

Harus ada strategi:

• retry dengan prompt yang diperketat,
• fallback model,
• atau minta human approval.

Mistake #4: Mengabaikan biaya token

Workflow multi-node bisa mahal. Pantau token per node, cache langkah yang stabil, dan gunakan model kecil untuk tugas sederhana.

Mistake #5: Tidak memisahkan dev/prod mode

Di dev kamu mungkin longgar. Di prod, semua harus ketat: timeout, sandbox, auth, rate limit, audit log.

---

8) Advanced Tips — Naik ke Level Berikutnya

Kalau fondasi di atas sudah jalan, upgrade ke level production:

1. Persistent memory ke Redis/Postgres
   Ganti in-memory store supaya sesi tahan restart.

2. Human-in-the-loop interrupt
   Tambah node approval sebelum eksekusi kode berisiko.

3. Multi-agent collaboration
   Pisahkan agent jadi Architect, Implementer, Reviewer.

4. Observability full stack
   Integrasikan tracing untuk lihat bottleneck dan failure pattern.

5. Policy engine
   Tambah rules eksplisit: tipe file apa boleh diubah, command apa dilarang, dsb.

6. Regression harness
   Simpan kumpulan task benchmark supaya kualitas agent bisa dibandingkan antar rilis.

---

9) Summary & Next Steps

Kita sudah membangun AI coding agent yang:

• terstruktur dengan LangGraph,
• punya alur planner → coder → executor → reviewer,
• memiliki guardrail eksekusi,
• expose API lewat FastAPI,
• dan menyimpan state sesi.

Next step yang saya sarankan:

1. Tambahkan autentikasi API key/JWT.
2. Pindahkan executor ke sandbox container terisolasi.
3. Simpan trace ke storage observability.
4. Tambahkan test otomatis untuk 20+ skenario coding.
5. Buat dashboard sederhana untuk melihat histori sesi agent.

Dengan begitu, kamu bergerak dari “demo AI” ke sistem agent engineering yang benar-benar usable di tim.

---

10) References

1. LangGraph Overview (Official Docs): https://docs.langchain.com/oss/python/langgraph/overview
2. LangGraph Quickstart: https://docs.langchain.com/oss/python/langgraph/quickstart
3. LangGraph GitHub Repository: https://github.com/langchain-ai/langgraph
4. LangChain Agents Docs: https://docs.langchain.com/oss/python/langchain/agents
5. FastAPI Official Docs: https://fastapi.tiangolo.com/
6. DEV Community (tren artikel AI/agents): https://dev.to
7. GitHub Trending (tren repo harian): https://github.com/trending
8. X Explore (diskusi real-time): https://x.com/explore

---

Kalau kamu mau, di tutorial lanjutan kita bisa bahas versi multi-agent coding pipeline (Architect Agent + Coder Agent + QA Agent) dengan approval flow per commit supaya cocok untuk tim produksi. 🚀