Home
Blog
LangChain 1.0 dan Milvus: Cara Membangun Agen Siap Produksi dengan Memori Jangka Panjang yang Nyata

LangChain 1.0 dan Milvus: Cara Membangun Agen Siap Produksi dengan Memori Jangka Panjang yang Nyata

Tutorials

December 19, 2025

Min Yin

LangChain adalah kerangka kerja sumber terbuka yang populer untuk mengembangkan aplikasi yang didukung oleh model bahasa besar (LLM). Framework ini menyediakan toolkit modular untuk membangun penalaran dan agen yang menggunakan alat, menghubungkan model ke data eksternal, dan mengelola alur interaksi.

Dengan dirilisnya LangChain 1.0, kerangka kerja ini mengambil langkah menuju arsitektur yang lebih ramah produksi. Versi baru ini menggantikan desain berbasis Chain sebelumnya dengan loop ReAct yang terstandardisasi (Reason → Tool Call → Observe → Decide) dan memperkenalkan Middleware untuk mengelola eksekusi, kontrol, dan keamanan.

Namun, penalaran saja tidak cukup. Agen juga membutuhkan kemampuan untuk menyimpan, mengingat, dan menggunakan kembali informasi. Di sinilah Milvus, sebuah database vektor sumber terbuka, dapat memainkan peran penting. Milvus menyediakan lapisan memori berkinerja tinggi yang dapat diskalakan yang memungkinkan agen untuk menyimpan, mencari, dan mengambil informasi secara efisien melalui kemiripan semantik.

Dalam tulisan ini, kita akan mengeksplorasi bagaimana LangChain 1.0 memperbarui arsitektur agen, dan bagaimana mengintegrasikan Milvus membantu agen melampaui penalaran - memungkinkan memori yang gigih dan cerdas untuk kasus penggunaan di dunia nyata.

Mengapa Desain Berbasis Rantai Gagal

Pada masa-masa awalnya (versi 0.x), arsitektur LangChain berpusat pada Rantai. Setiap Chain mendefinisikan urutan tetap dan dilengkapi dengan templat yang sudah dibuat sebelumnya yang membuat orkestrasi LLM menjadi sederhana dan cepat. Desain ini sangat bagus untuk membangun prototipe dengan cepat. Tetapi ketika ekosistem LLM berevolusi dan kasus penggunaan di dunia nyata menjadi lebih kompleks, celah-celah dalam arsitektur ini mulai terlihat.

1. Kurangnya Fleksibilitas

Versi awal LangChain menyediakan jalur pipa modular seperti SimpleSequentialChain atau LLMChain, masing-masing mengikuti alur tetap dan linier - pembuatan → pemanggilan model → pemrosesan keluaran. Desain ini bekerja dengan baik untuk tugas-tugas yang sederhana dan dapat diprediksi serta memudahkan pembuatan prototipe dengan cepat.

Namun, ketika aplikasi menjadi lebih dinamis, template yang kaku ini mulai terasa membatasi. Ketika logika bisnis tidak lagi sesuai dengan urutan yang telah ditentukan, Anda memiliki dua pilihan yang tidak memuaskan: memaksa logika Anda untuk menyesuaikan diri dengan kerangka kerja atau melewatinya sepenuhnya dengan memanggil API LLM secara langsung.

2. Kurangnya Kontrol Tingkat Produksi

Apa yang bekerja dengan baik dalam demo sering kali rusak dalam produksi. Rantai tidak menyertakan perlindungan yang diperlukan untuk aplikasi berskala besar, persisten, atau sensitif. Masalah umum yang termasuk:

Konteks meluap: Percakapan yang panjang dapat melebihi batas token, menyebabkan crash atau pemotongan diam.
Kebocoran data sensitif: Informasi yang dapat diidentifikasi secara pribadi (seperti email atau ID) dapat secara tidak sengaja dikirim ke model pihak ketiga.
Operasi tanpa pengawasan: Agen dapat menghapus data atau mengirim email tanpa persetujuan manusia.

3. Kurangnya Kompatibilitas Lintas Model

Setiap penyedia LLM-OpenAI, Anthropic, dan banyak model Cina-menerapkan protokolnya sendiri untuk penalaran dan pemanggilan alat. Setiap kali Anda berganti penyedia, Anda harus menulis ulang lapisan integrasi: templat prompt, adaptor, dan pengurai respons. Pekerjaan yang berulang-ulang ini memperlambat pengembangan dan membuat eksperimen menjadi menyakitkan.

LangChain 1.0: Agen ReAct yang lengkap

Ketika tim LangChain menganalisis ratusan implementasi agen tingkat produksi, satu wawasan menonjol: hampir semua agen yang sukses secara alami menyatu pada pola ReAct ("Penalaran + Tindakan").

Baik dalam sistem multi-agen atau agen tunggal yang melakukan penalaran mendalam, loop kontrol yang sama muncul: bergantian antara langkah-langkah penalaran singkat dengan pemanggilan alat yang ditargetkan, kemudian memasukkan pengamatan yang dihasilkan ke dalam keputusan berikutnya sampai agen dapat memberikan jawaban akhir.

Untuk membangun struktur yang telah terbukti ini, LangChain 1.0 menempatkan loop ReAct sebagai inti dari arsitekturnya, menjadikannya struktur default untuk membangun agen yang dapat diandalkan, dapat ditafsirkan, dan siap produksi.

Untuk mendukung segala sesuatu mulai dari agen sederhana hingga orkestrasi yang rumit, LangChain 1.0 mengadopsi desain berlapis yang menggabungkan kemudahan penggunaan dengan kontrol yang tepat:

Skenario standar: Mulailah dengan fungsi create_agent () - perulangan ReAct yang bersih dan terstandardisasi yang menangani penalaran dan pemanggilan alat secara langsung.
Skenario yang diperluas: Tambahkan Middleware untuk mendapatkan kontrol yang lebih baik. Middleware memungkinkan Anda memeriksa atau memodifikasi apa yang terjadi di dalam agen - misalnya, menambahkan deteksi PII, pos pemeriksaan persetujuan manusia, percobaan ulang otomatis, atau kait pemantauan.
Skenario yang kompleks: Untuk alur kerja stateful atau orkestrasi multi-agen, gunakan LangGraph, mesin eksekusi berbasis grafik yang menyediakan kontrol yang tepat atas aliran logika, ketergantungan, dan status eksekusi.

Sekarang mari kita uraikan tiga komponen utama yang membuat pengembangan agen menjadi lebih sederhana, lebih aman, dan lebih konsisten di seluruh model.

1. Fungsi create_agent(): Cara yang Lebih Sederhana untuk Membangun Agen

Terobosan utama dalam LangChain 1.0 adalah bagaimana ia mengurangi kerumitan dalam membangun agen menjadi satu fungsi - create_agent(). Anda tidak perlu lagi menangani manajemen state, penanganan kesalahan, atau streaming output secara manual. Fitur-fitur tingkat produksi ini sekarang secara otomatis dikelola oleh runtime LangGraph di bawahnya.

Hanya dengan tiga parameter, Anda dapat meluncurkan agen yang berfungsi penuh:

model - pengenal model (string) atau objek model yang di-instansiasi.
tools - daftar fungsi yang memberikan agen kemampuannya.
system_prompt - instruksi yang mendefinisikan peran, nada, dan perilaku agen.

Di bawah tenda, create_agent() berjalan pada perulangan agen standar - memanggil model, membiarkannya memilih alat untuk dieksekusi, dan menyelesaikannya ketika tidak ada lagi alat yang dibutuhkan:

Ia juga mewarisi kemampuan bawaan LangGraph untuk state persistence, pemulihan gangguan, dan streaming. Tugas-tugas yang dulunya membutuhkan ratusan baris kode orkestrasi sekarang ditangani melalui satu API deklaratif.

from langchain.agents import create_agent
agent = create_agent(
    model="openai:gpt-4o",
    tools=[get_weather, query_database],
    system_prompt="You are a customer service assistant who helps users check the weather and order information."
)
result = agent.invoke({
    "messages": [{"role": "user", "content": "What’s the weather like in Shanghai today?"}]
})

2. Middleware: Lapisan yang Dapat Disusun untuk Kontrol yang Siap Produksi

Middleware adalah jembatan utama yang membawa LangChain dari prototipe ke produksi. Middleware mengekspos hook pada titik-titik strategis dalam loop eksekusi agen, memungkinkan Anda untuk menambahkan logika khusus tanpa menulis ulang proses inti ReAct.

Putaran utama agen mengikuti proses keputusan tiga langkah - Model → Alat → Penghentian:

LangChain 1.0 menyediakan beberapa middleware yang sudah jadi untuk pola-pola umum. Berikut adalah empat contohnya.

Deteksi PII: Aplikasi apa pun yang menangani data pengguna yang sensitif

from langchain.agents import create_agent
from langchain.agents.middleware import PIIMiddleware
agent = create_agent(
model=“gpt-4o”,
tools=[],  # Add tools as needed
middleware=[
# Redact emails in user input
PIIMiddleware(“email”, strategy=“redact”, apply_to_input=True),
# Mask credit cards (show last 4 digits)
PIIMiddleware(“credit_card”, strategy=“mask”, apply_to_input=True),
# Custom PII type with regex
PIIMiddleware(
“api_key”,
detector=r"sk-[a-zA-Z0-9]{32}",
strategy=“block”,  # Raise error if detected
),
],
)

Peringkasan: Secara otomatis meringkas riwayat percakapan ketika mendekati batas token.

from langchain.agents import create_agent
from langchain.agents.middleware import SummarizationMiddleware
agent = create_agent(
model=“gpt-4o”,
tools=[weather_tool, calculator_tool],
middleware=[
SummarizationMiddleware(
model=“gpt-4o-mini”,  #Summarize using a cheaper model  
max_tokens_before_summary=4000,  # Trigger summarization at 4000 tokens
messages_to_keep=20,  # Keep last 20 messages after summary
),
],
)

Uji coba alat: Secara otomatis mencoba kembali panggilan alat yang gagal dengan backoff eksponensial yang dapat dikonfigurasi.

from langchain.agents import create_agent
from langchain.agents.middleware import ToolRetryMiddleware
agent = create_agent(
    model="gpt-4o",
    tools=[search_tool, database_tool],
    middleware=[
        ToolRetryMiddleware(
            max_retries=3,  # Retry up to 3 times
            backoff_factor=2.0,  # Exponential backoff multiplier
            initial_delay=1.0,  # Start with 1 second delay
            max_delay=60.0,  # Cap delays at 60 seconds
            jitter=True,  # Add random jitter to avoid thundering herd (±25%)
    ),
],

)

Middleware Khusus

Selain opsi middleware resmi yang sudah ada sebelumnya, Anda juga dapat membuat middleware khusus menggunakan cara berbasis dekorator atau berbasis kelas.

Sebagai contoh, cuplikan di bawah ini menunjukkan cara mencatat pemanggilan model sebelum dieksekusi:

from langchain.agents.middleware import before_model
from langchain.agents.middleware import AgentState
from langgraph.runtime import Runtime
@before_model
def log_before_model(state: AgentState, runtime: Runtime) -> dict | None:
    print(f"About to call model with {len(state['messages'])} messages")
    return None  # Returning None means the normal flow continues
agent = create_agent(
    model="openai:gpt-4o",
    tools=[...],
    middleware=[log_before_model],
)

3. Keluaran Terstruktur: Cara Terstandar untuk Menangani Data

Dalam pengembangan agen tradisional, output terstruktur selalu sulit untuk dikelola. Setiap penyedia model menanganinya secara berbeda - misalnya, OpenAI menawarkan API Output Terstruktur asli, sementara yang lain hanya mendukung respons terstruktur secara tidak langsung melalui pemanggilan alat. Hal ini sering kali berarti menulis adaptor khusus untuk setiap penyedia, menambah pekerjaan ekstra dan membuat pemeliharaan lebih menyakitkan daripada yang seharusnya.

Di LangChain 1.0, output terstruktur ditangani secara langsung melalui parameter response_format di create_agent(). Anda hanya perlu mendefinisikan skema data Anda sekali saja. LangChain secara otomatis memilih strategi penegakan terbaik berdasarkan model yang Anda gunakan - tidak perlu pengaturan tambahan atau kode khusus vendor.

from langchain.agents import create_agent
from pydantic import BaseModel, Field
class WeatherReport(BaseModel):
    location: str = Field(description="City name")
    temperature: float = Field(description="Temperature (°C)")
    condition: str = Field(description="Weather condition")
agent = create_agent(
    model="openai:gpt-4o",
    tools=[get_weather],
    response_format=WeatherReport  # Use the Pydantic model as the response schema
)
result = agent.invoke({"role": "user", "content": "What’s the weather like in Shanghai today??"})
weather_data = result['structured_response']  # Retrieve the structured response
print(f"{weather_data.location}: {weather_data.temperature}°C, {weather_data.condition}")

LangChain mendukung dua strategi untuk output terstruktur:

1. Strategi Penyedia: Beberapa penyedia model secara native mendukung output terstruktur melalui API mereka (misalnya OpenAI dan Grok). Ketika dukungan tersebut tersedia, LangChain menggunakan penegakan skema bawaan penyedia secara langsung. Pendekatan ini menawarkan tingkat keandalan dan konsistensi tertinggi, karena model itu sendiri menjamin format output.

2. Strategi Pemanggilan Alat: Untuk model yang tidak mendukung output terstruktur asli, LangChain menggunakan pemanggilan alat untuk mencapai hasil yang sama.

Anda tidak perlu khawatir tentang strategi mana yang digunakan - kerangka kerja mendeteksi kemampuan model dan beradaptasi secara otomatis. Abstraksi ini memungkinkan Anda beralih di antara penyedia model yang berbeda secara bebas tanpa mengubah logika bisnis Anda.

Bagaimana Milvus Meningkatkan Memori Agen

Untuk agen tingkat produksi, hambatan kinerja yang sebenarnya sering kali bukan pada mesin penalaran - tetapi pada sistem memori. Dalam LangChain 1.0, basis data vektor bertindak sebagai memori eksternal agen, memberikan daya ingat jangka panjang melalui pengambilan semantik.

Milvus adalah salah satu basis data vektor sumber terbuka paling matang yang tersedia saat ini, yang dibuat khusus untuk pencarian vektor berskala besar dalam aplikasi AI. Milvus terintegrasi secara native dengan LangChain, sehingga Anda tidak perlu menangani vektorisasi, manajemen indeks, atau pencarian kemiripan secara manual. Paket langchain_milvus membungkus Milvus sebagai antarmuka VectorStore standar, memungkinkan Anda untuk menghubungkannya ke agen Anda hanya dengan beberapa baris kode.

Dengan demikian, Milvus menjawab tiga tantangan utama dalam membangun sistem memori agen yang dapat diskalakan dan dapat diandalkan:

1. Pengambilan Cepat dari Basis Pengetahuan yang Masif

Ketika seorang agen perlu memproses ribuan dokumen, percakapan sebelumnya, atau manual produk, pencarian kata kunci yang sederhana tidaklah cukup. Milvus menggunakan pencarian kemiripan vektor untuk menemukan informasi yang relevan secara semantik dalam hitungan milidetik - bahkan jika kueri menggunakan kata-kata yang berbeda. Hal ini memungkinkan agen Anda untuk mengingat pengetahuan berdasarkan makna, bukan hanya pencocokan teks yang sama persis.

from langchain.agents import create_agent
from langchain_milvus import Milvus
from langchain_openai import OpenAIEmbeddings
# Initialize the vector database as a knowledge base
vectorstore = Milvus(
    embedding=OpenAIEmbeddings(),  
    collection_name="company_knowledge",
    connection_args={"uri": "http://localhost:19530"}  #
)
# Convert the retriever into a Tool for the Agent
agent = create_agent(
    model="openai:gpt-4o",
    tools=[vectorstore.as_retriever().as_tool(
        name="knowledge_search",
        description="Search the company knowledge base to answer professional questions"
    )],
    system_prompt="You can retrieve information from the knowledge base to answer questions."
)

2. Memori Jangka Panjang yang Persisten

SummarizationMiddleware LangChain dapat memadatkan riwayat percakapan jika terlalu panjang, tetapi apa yang terjadi dengan semua detail yang diringkas? Milvus menyimpannya. Setiap percakapan, pemanggilan alat, dan langkah penalaran dapat divisualisasikan dan disimpan untuk referensi jangka panjang. Saat dibutuhkan, agen dapat dengan cepat mengambil memori yang relevan melalui pencarian semantik, sehingga memungkinkan kesinambungan yang sebenarnya di seluruh sesi.

from langchain_milvus import Milvus
from langchain.agents import create_agent
from langchain.agents.middleware import SummarizationMiddleware
from langgraph.checkpoint.memory import InMemorySaver
# Long-term memory storage(Milvus)
long_term_memory = Milvus.from_documents(
    documents=[],  # Initially empty; dynamically updated at runtime
    embedding=OpenAIEmbeddings(),
    connection_args={"uri": "./agent_memory.db"}
)
# Short-term memory management(LangGraph Checkpointer + Summarization)
agent = create_agent(
    model="openai:gpt-4o",
    tools=[long_term_memory.as_retriever().as_tool(
        name="recall_memory",
        description="Retrieve the agent’s historical memories and past experiences"
    )],
    checkpointer=InMemorySaver(),  # Short-term memory
    middleware=[
        SummarizationMiddleware(
            model="openai:gpt-4o-mini",
            max_tokens_before_summary=4000  # When the threshold is exceeded, summarize and store it in Milvus
        )
    ]
)

3. Manajemen Terpadu Konten Multimodal

Agen modern menangani lebih dari sekadar teks - mereka berinteraksi dengan gambar, audio, dan video. Milvus mendukung penyimpanan multi-vektor dan skema dinamis, sehingga Anda dapat mengelola penyematan dari berbagai modalitas dalam satu sistem. Hal ini memberikan fondasi memori terpadu untuk agen multimodal, memungkinkan pengambilan yang konsisten di berbagai jenis data.

# Filter retrievals by source (e.g., search only medical reports)
vectorstore.similarity_search(
    query="What is the patient's blood pressure reading?",
    k=3,
    expr="source == 'medical_reports' AND modality == 'text'"  # Milvus scalar filtering
)

LangChain vs LangGraph: Cara Memilih yang Cocok untuk Agen Anda

Meningkatkan ke LangChain 1.0 adalah langkah penting untuk membangun agen kelas produksi - tetapi itu tidak berarti itu selalu menjadi satu-satunya pilihan terbaik untuk setiap kasus penggunaan. Memilih kerangka kerja yang tepat menentukan seberapa cepat Anda dapat menggabungkan kemampuan ini ke dalam sistem yang berfungsi dan dapat dipelihara.

Sebenarnya, LangChain 1.0 dan LangGraph 1.0 dapat dilihat sebagai bagian dari tumpukan berlapis yang sama, yang dirancang untuk bekerja bersama daripada saling menggantikan: LangChain membantu Anda membangun agen standar dengan cepat, sementara LangGraph memberikan Anda kontrol yang lebih baik untuk alur kerja yang kompleks. Dengan kata lain, LangChain membantu Anda bergerak cepat, sementara LangGraph membantu Anda masuk lebih dalam.

Di bawah ini adalah perbandingan singkat tentang bagaimana mereka berbeda dalam pemosisian teknis:

Dimensi	LangChain 1.0	LangChain 1.0
Tingkat Abstraksi	Abstraksi tingkat tinggi, dirancang untuk skenario agen standar	Kerangka kerja orkestrasi tingkat rendah, dirancang untuk alur kerja yang kompleks
Kemampuan Inti	Perulangan ReAct standar (Alasan → Panggilan Alat → Pengamatan → Tanggapan)	Mesin status khusus dan logika percabangan yang kompleks (StateGraph + Perutean Bersyarat)
Mekanisme Ekstensi	Middleware untuk kemampuan tingkat produksi	Manajemen manual untuk node, edge, dan transisi state
Implementasi yang Mendasari	Manajemen manual dari node, edge, dan transisi state	Runtime asli dengan persistensi dan pemulihan bawaan
Kasus Penggunaan Umum	80% dari skenario agen standar	Kolaborasi multi-agen dan orkestrasi alur kerja jangka panjang
Kurva Pembelajaran	Membangun agen dalam ~10 baris kode	Membutuhkan pemahaman tentang state graph dan orkestrasi node

Jika Anda baru dalam membangun agen atau ingin membuat proyek berjalan dengan cepat, mulailah dengan LangChain. Jika Anda sudah mengetahui kasus penggunaan Anda membutuhkan orkestrasi yang kompleks, kolaborasi multi-agen, atau alur kerja yang sudah berjalan lama, langsung saja ke LangGraph.

Kedua kerangka kerja ini dapat hidup berdampingan dalam proyek yang sama - Anda dapat memulai dari yang sederhana dengan LangChain dan menggunakan LangGraph ketika sistem Anda membutuhkan lebih banyak kontrol dan fleksibilitas. Kuncinya adalah memilih alat yang tepat untuk setiap bagian dari alur kerja Anda.

Kesimpulan

Tiga tahun yang lalu, LangChain dimulai sebagai pembungkus yang ringan untuk memanggil LLM. Saat ini, ia telah berkembang menjadi kerangka kerja tingkat produksi yang lengkap.

Pada intinya, lapisan middleware memberikan keamanan, kepatuhan, dan kemampuan pengamatan. LangGraph menambahkan eksekusi yang terus-menerus, aliran kontrol, dan manajemen state. Dan pada lapisan memori, Milvus mengisi celah kritis - menyediakan memori jangka panjang yang dapat diskalakan dan dapat diandalkan yang memungkinkan agen untuk mengambil konteks, menalar sejarah, dan meningkatkannya dari waktu ke waktu.

Bersama-sama, LangChain, LangGraph, dan Milvus membentuk sebuah rantai alat praktis untuk era agen modern - menjembatani pembuatan prototipe yang cepat dengan penerapan skala perusahaan, tanpa mengorbankan keandalan atau kinerja.

🚀 Siap memberi agen Anda memori jangka panjang yang andal? Jelajahi Milvus dan lihat bagaimana Milvus mendukung memori jangka panjang yang cerdas untuk agen LangChain dalam produksi.

Ada pertanyaan atau ingin mendalami fitur apa pun? Bergabunglah dengan saluran Discord kami atau ajukan pertanyaan di GitHub. Anda juga dapat memesan sesi tatap muka selama 20 menit untuk mendapatkan wawasan, panduan, dan jawaban atas pertanyaan Anda melalui Jam Kerja Milvus.