Melampaui Kelebihan Konteks: Bagaimana Parlant × Milvus Memberikan Kontrol dan Kejelasan pada Perilaku Agen LLM
Bayangkan jika Anda diminta untuk menyelesaikan tugas yang melibatkan 200 aturan bisnis, 50 alat bantu, dan 30 demo, dan Anda hanya memiliki waktu satu jam untuk mengerjakannya. Hal itu sangat tidak mungkin. Namun kita sering mengharapkan model bahasa yang besar untuk melakukan hal tersebut ketika kita mengubahnya menjadi "agen" dan membebani mereka dengan instruksi.
Dalam praktiknya, pendekatan ini dengan cepat rusak. Kerangka kerja agen tradisional, seperti LangChain atau LlamaIndex, menyuntikkan semua aturan dan alat ke dalam konteks model sekaligus, yang mengarah pada konflik aturan, konteks yang berlebihan, dan perilaku yang tidak dapat diprediksi dalam produksi.
Untuk mengatasi masalah ini, sebuah kerangka kerja agen sumber terbuka yang disebut Parlant baru-baru ini mendapatkan daya tarik di GitHub. Parlant memperkenalkan pendekatan baru yang disebut Alignment Modeling, bersama dengan mekanisme pengawasan dan transisi bersyarat yang membuat perilaku agen jauh lebih terkendali dan dapat dijelaskan.
Ketika dipasangkan dengan Milvus, sebuah basis data vektor sumber terbuka, Parlant menjadi lebih mumpuni. Milvus menambahkan kecerdasan semantik, yang memungkinkan agen secara dinamis mengambil aturan dan konteks yang paling relevan secara real time-menjaga agar tetap akurat, efisien, dan siap produksi.
Dalam artikel ini, kita akan mengeksplorasi bagaimana Parlant bekerja di balik layar-dan bagaimana mengintegrasikannya dengan Milvus memungkinkan tingkat produksi.
Mengapa Kerangka Kerja Agen Tradisional Berantakan
Kerangka kerja agen tradisional suka menjadi besar: ratusan aturan, lusinan alat, dan beberapa demo-semuanya dijejalkan ke dalam satu prompt yang terlalu banyak. Ini mungkin terlihat bagus dalam demo atau uji coba kotak pasir kecil, tetapi begitu Anda mendorongnya ke dalam produksi, celah-celahnya mulai terlihat dengan cepat.
Aturan yang Bertentangan Membawa Kekacauan: Ketika dua atau lebih aturan berlaku pada saat yang sama, kerangka kerja ini tidak memiliki cara bawaan untuk memutuskan mana yang menang. Kadang-kadang memilih salah satu. Kadang-kadang memadukan keduanya. Kadang-kadang melakukan sesuatu yang sama sekali tidak dapat diprediksi.
Kasus-kasus Tepi Mengekspos Kesenjangan: Anda tidak mungkin dapat memprediksi semua yang akan dikatakan oleh pengguna. Dan ketika model Anda menemukan sesuatu di luar data pelatihannya, model akan menggunakan jawaban yang umum dan tidak berkomitmen.
Debugging itu Menyakitkan dan Mahal: Ketika sebuah agen berperilaku buruk, hampir tidak mungkin untuk menentukan aturan mana yang menyebabkan masalah. Karena semuanya berada di dalam satu prompt sistem raksasa, satu-satunya cara untuk memperbaikinya adalah menulis ulang prompt dan menguji ulang semuanya dari awal.
Apa itu Parlant dan Bagaimana Cara Kerjanya
Parlant adalah Mesin Penyelarasan sumber terbuka untuk agen LLM. Anda dapat secara tepat mengontrol bagaimana agen berperilaku di berbagai skenario dengan memodelkan proses pengambilan keputusan dengan cara yang terstruktur dan berbasis aturan.
Untuk mengatasi masalah yang ditemukan dalam kerangka kerja agen tradisional, Parlant memperkenalkan pendekatan baru yang kuat: Pemodelan Penyelarasan. Ide intinya adalah memisahkan definisi aturan dari eksekusi aturan, memastikan bahwa hanya aturan yang paling relevan yang dimasukkan ke dalam konteks LLM pada waktu tertentu.
Pedoman Granular: Inti dari Pemodelan Penyelarasan
Inti dari model penyelarasan Parlant adalah konsep Granular Guidelines. Alih-alih menulis satu perintah sistem raksasa yang penuh dengan aturan, Anda mendefinisikan pedoman kecil dan modular - masing-masing menjelaskan bagaimana agen harus menangani jenis situasi tertentu.
Setiap pedoman terdiri dari tiga bagian:
Kondisi - Deskripsi bahasa alami tentang kapan aturan harus diterapkan. Parlant mengubah kondisi ini menjadi vektor semantik dan mencocokkannya dengan input pengguna untuk mengetahui apakah kondisi tersebut relevan.
Tindakan - Instruksi yang jelas yang mendefinisikan bagaimana agen harus merespons setelah kondisi terpenuhi. Tindakan ini disuntikkan ke dalam konteks LLM hanya ketika dipicu.
Alat - Setiap fungsi eksternal atau API yang terkait dengan aturan tertentu. Ini diekspos ke agen hanya ketika pedoman aktif, menjaga penggunaan alat tetap terkendali dan sesuai konteks.
await agent.create_guideline(
condition="The user asks about a refund and the order amount exceeds 500 RMB",
action="First call the order status check tool to confirm whether the refund conditions are met, then provide a detailed explanation of the refund process",
tools=[check_order_status, calculate_refund_amount]
)
Setiap kali pengguna berinteraksi dengan agen, Parlant menjalankan langkah pencocokan ringan untuk menemukan tiga hingga lima pedoman yang paling relevan. Hanya aturan-aturan tersebut yang dimasukkan ke dalam konteks model, menjaga agar petunjuk tetap ringkas dan terfokus sambil memastikan bahwa agen secara konsisten mengikuti aturan yang tepat.
Mekanisme Pengawasan untuk Akurasi dan Konsistensi
Untuk menjaga akurasi dan konsistensi lebih lanjut, Parlant memperkenalkan mekanisme pengawasan yang bertindak sebagai kontrol kualitas lapisan kedua. Prosesnya berlangsung dalam tiga langkah:
1. Menghasilkan respons kandidat - Agen membuat balasan awal berdasarkan panduan yang sesuai dan konteks percakapan saat ini.
2. Memeriksa kesesuaian - Tanggapan tersebut dibandingkan dengan panduan aktif untuk memverifikasi bahwa setiap instruksi telah diikuti dengan benar.
3. Merevisi atau mengonfirmasi - Jika ada masalah yang ditemukan, sistem akan mengoreksi output; jika semuanya sesuai, balasan akan disetujui dan dikirim ke pengguna.
Mekanisme pengawasan ini memastikan bahwa agen tidak hanya memahami aturan tetapi juga benar-benar mematuhinya sebelum membalas-memperbaiki keandalan dan kontrol.
Transisi Bersyarat untuk Kontrol dan Keamanan
Dalam kerangka kerja agen tradisional, setiap alat yang tersedia diekspos ke LLM setiap saat. Pendekatan "semua yang ada di atas meja" ini sering kali menyebabkan permintaan yang berlebihan dan pemanggilan alat yang tidak diinginkan. Parlant memecahkan masalah ini melalui transisi bersyarat. Mirip dengan cara kerja state machine, sebuah aksi atau alat hanya dipicu ketika kondisi tertentu terpenuhi. Setiap alat terikat erat dengan pedoman yang sesuai, dan alat tersebut hanya akan tersedia ketika kondisi pedoman tersebut diaktifkan.
# The balance inquiry tool is exposed only when the condition "the user wants to make a transfer" is met
await agent.create_guideline(
condition="The user wants to make a transfer",
action="First check the account balance. If the balance is below 500 RMB, remind the user that an overdraft fee may apply.",
tools=[get_user_account_balance]
)
Mekanisme ini mengubah pemanggilan alat menjadi transisi bersyarat-alat berpindah dari "tidak aktif" menjadi "aktif" hanya ketika kondisi pemicunya terpenuhi. Dengan menyusun eksekusi dengan cara ini, Parlant memastikan bahwa setiap tindakan terjadi dengan sengaja dan kontekstual, mencegah penyalahgunaan sekaligus meningkatkan efisiensi dan keamanan sistem.
Bagaimana Milvus Memberdayakan Parlant
Ketika kita melihat di balik proses pencocokan pedoman Parlant, satu tantangan teknis utama menjadi jelas: bagaimana sistem dapat menemukan tiga hingga lima aturan yang paling relevan dari ratusan - atau bahkan ribuan - pilihan hanya dalam beberapa milidetik? Di situlah letak peran database vektor. Pengambilan semantik adalah hal yang memungkinkan hal ini terjadi.
Bagaimana Milvus Mendukung Proses Pencocokan Pedoman Parlant
Pencocokan pedoman bekerja melalui kesamaan semantik. Bidang Kondisi setiap pedoman diubah menjadi penyematan vektor, menangkap maknanya dan bukan hanya teks harfiahnya. Ketika pengguna mengirim pesan, Parlant membandingkan semantik pesan tersebut dengan semua penyematan pedoman yang tersimpan untuk menemukan yang paling relevan.
Berikut ini cara kerja prosesnya selangkah demi selangkah:
1. Menyandikan kueri - Pesan pengguna dan riwayat percakapan terakhir diubah menjadi vektor kueri.
2. Cari kemiripan - Sistem melakukan pencarian kemiripan di dalam penyimpanan vektor panduan untuk menemukan kecocokan terdekat.
3. Mengambilhasil Top-K - Tiga hingga lima pedoman yang paling relevan secara semantik dikembalikan.
4. Suntikkanke dalam konteks - Pedoman yang cocok ini kemudian secara dinamis dimasukkan ke dalam konteks LLM sehingga model dapat bertindak sesuai dengan aturan yang benar.
Untuk memungkinkan alur kerja ini, basis data vektor harus memberikan tiga kemampuan penting: pencarian Approximate Nearest Neighbor (ANN) berkinerja tinggi, pemfilteran metadata yang fleksibel, dan pembaruan vektor secara real-time. Milvus, basis data vektor open-source yang berasal dari cloud, memberikan kinerja tingkat produksi di ketiga area tersebut.
Untuk memahami cara kerja Milvus dalam skenario nyata, mari kita lihat agen layanan keuangan sebagai contoh.
Misalkan sistem mendefinisikan 800 panduan bisnis yang mencakup tugas-tugas seperti pertanyaan rekening, transfer dana, dan konsultasi produk manajemen kekayaan. Dalam pengaturan ini, Milvus bertindak sebagai lapisan penyimpanan dan pengambilan untuk semua data pedoman.
from pymilvus import connections, Collection, FieldSchema, CollectionSchema, DataType
import parlant.sdk as p
# Connect to Milvus
connections.connect(host=“localhost”, port=“19530”)
# Define the schema for the guideline collection
fields = [
FieldSchema(name=“guideline_id”, dtype=DataType.VARCHAR, max_length=100, is_primary=True),
FieldSchema(name=“condition_vector”, dtype=DataType.FLOAT_VECTOR, dim=768),
FieldSchema(name=“condition_text”, dtype=DataType.VARCHAR, max_length=1000),
FieldSchema(name=“action_text”, dtype=DataType.VARCHAR, max_length=2000),
FieldSchema(name=“priority”, dtype=DataType.INT64),
FieldSchema(name=“business_domain”, dtype=DataType.VARCHAR, max_length=50)
]
schema = CollectionSchema(fields=fields, description=“Agent Guidelines”)
guideline_collection = Collection(name=“agent_guidelines”, schema=schema)
# Create an HNSW index for high-performance retrieval
index_params = {
“index_type”: “HNSW”,
“metric_type”: “COSINE”,
“params”: {“M”: 16, “efConstruction”: 200}
}
guideline_collection.create_index(field_name=“condition_vector”, index_params=index_params)
Sekarang, ketika pengguna mengatakan "Saya ingin mentransfer 100.000 RMB ke rekening ibu saya", alur runtime-nya adalah:
1. Rektoratisasi kueri - Ubah masukan pengguna menjadi vektor 768 dimensi.
2. Pengambilan hibrida - Menjalankan pencarian kemiripan vektor di Milvus dengan pemfilteran metadata (mis., business_domain="transfer").
3. Pemeringkatan hasil - Memberi peringkat pada kandidat panduan berdasarkan nilai kemiripan yang dikombinasikan dengan nilai prioritasnya.
4. Injeksi konteks - Suntikkan Top-3 pedoman yang cocok ' action_text ke dalam konteks agen Parlant.
Dalam konfigurasi ini, Milvus memberikan latensi P99 di bawah 15 ms, bahkan ketika pustaka panduan berskala hingga 100.000 entri. Sebagai perbandingan, menggunakan basis data relasional tradisional dengan pencocokan kata kunci biasanya menghasilkan latensi di atas 200 ms dan akurasi pencocokan yang jauh lebih rendah.
Bagaimana Milvus Memungkinkan Memori Jangka Panjang dan Personalisasi
Milvus melakukan lebih dari sekadar pencocokan pedoman. Dalam skenario di mana agen membutuhkan memori jangka panjang dan respons yang dipersonalisasi, Milvus dapat berfungsi sebagai lapisan memori yang menyimpan dan mengambil interaksi pengguna di masa lalu sebagai penyematan vektor, membantu agen mengingat apa yang telah didiskusikan sebelumnya.
# store user’s past interactions
user_memory_fields = [
FieldSchema(name="interaction_id", dtype=DataType.VARCHAR, max_length=100, is_primary=True),
FieldSchema(name="user_id", dtype=DataType.VARCHAR, max_length=50),
FieldSchema(name="interaction_vector", dtype=DataType.FLOAT_VECTOR, dim=768),
FieldSchema(name="interaction_summary", dtype=DataType.VARCHAR, max_length=500),
FieldSchema(name="timestamp", dtype=DataType.INT64)
]
memory_collection = Collection(name="user_memory", schema=CollectionSchema(user_memory_fields))
Ketika pengguna yang sama kembali, agen dapat mengambil interaksi historis yang paling relevan dari Milvus dan menggunakannya untuk menghasilkan pengalaman yang lebih terhubung dan seperti manusia. Misalnya, jika pengguna bertanya tentang dana investasi minggu lalu, agen dapat mengingat konteks tersebut dan merespons secara proaktif: "Selamat datang kembali! Apakah Anda masih memiliki pertanyaan tentang reksa dana yang kita bahas terakhir kali?"
Cara Mengoptimalkan Kinerja untuk Sistem Agen yang Didukung Milvus
Ketika menerapkan sistem agen yang didukung oleh Milvus di lingkungan produksi, penyetelan kinerja menjadi sangat penting. Untuk mencapai latensi rendah dan throughput tinggi, beberapa parameter kunci perlu diperhatikan:
1. Memilih Jenis Indeks yang Tepat
Penting untuk memilih struktur indeks yang sesuai. Sebagai contoh, HNSW (Hierarchical Navigable Small World) sangat ideal untuk skenario dengan tingkat penarikan tinggi seperti keuangan atau perawatan kesehatan, di mana akurasi sangat penting. IVF_FLAT bekerja lebih baik untuk aplikasi berskala besar seperti rekomendasi e-commerce, di mana recall yang sedikit lebih rendah dapat diterima dengan imbalan kinerja yang lebih cepat dan penggunaan memori yang lebih sedikit.
2. Strategi Pemecahan
Ketika jumlah pedoman yang disimpan melebihi satu juta entri, disarankan untuk menggunakan Partisi untuk membagi data berdasarkan domain bisnis atau kasus penggunaan. Partisi mengurangi ruang pencarian per kueri, meningkatkan kecepatan pengambilan dan menjaga latensi tetap stabil meskipun kumpulan data bertambah.
3. Konfigurasi Cache
Untuk panduan yang sering diakses seperti kueri pelanggan standar atau alur kerja dengan lalu lintas tinggi, Anda dapat menggunakan cache hasil kueri Milvus. Hal ini memungkinkan sistem untuk menggunakan kembali hasil sebelumnya, mengurangi latensi hingga di bawah 5 milidetik untuk pencarian berulang.
Demo Langsung: Cara Membangun Sistem Tanya Jawab Cerdas dengan Parlant dan Milvus Lite
Milvus Lite adalah versi ringan dari Milvus - pustaka Python yang dapat dengan mudah disematkan ke dalam aplikasi Anda. Sangat ideal untuk membuat prototipe cepat di lingkungan seperti Notebook Jupyter atau untuk berjalan di perangkat edge dan perangkat pintar dengan sumber daya komputasi yang terbatas. Meskipun berukuran kecil, Milvus Lite mendukung API yang sama dengan penerapan Milvus lainnya. Ini berarti kode sisi klien yang Anda tulis untuk Milvus Lite dapat terhubung dengan mulus ke instance Milvus atau Zilliz Cloud yang lengkap nantinya - tidak perlu melakukan pemfaktoran ulang.
Dalam demo ini, kami akan menggunakan Milvus Lite bersama dengan Parlant untuk mendemonstrasikan cara membangun sistem Tanya Jawab cerdas yang memberikan jawaban yang cepat dan sesuai konteks dengan penyiapan yang minimal.
Prasyarat: Persyaratan
1. Parlant GitHub: https://github.com/emcie-co/parlant
2. Dokumentasi Parlant: https://parlant.io/docs
3.python3.10+
4.OpenAI_key
5. MlivusLite
Langkah 1: Instal Ketergantungan
# Install required Python packages
pip install pymilvus parlant openai
# Or, if you’re using a Conda environment:
conda activate your_env_name
pip install pymilvus parlant openai
Langkah 2: Konfigurasi Variabel Lingkungan
# Set your OpenAI API key
export OPENAI_API_KEY="your_openai_api_key_here"
# Verify that the variable is set correctly
echo $OPENAI_API_KEY
Langkah 3: Menerapkan Kode Inti
- Buat Embedder OpenAI khusus
class OpenAIEmbedder(p.Embedder):
# Converts text into vector embeddings with built-in timeout and retry
# Dimension: 1536 (text-embedding-3-small)
# Timeout: 60 seconds; Retries: up to 2 times
- Inisialisasi basis pengetahuan
1. Buat koleksi Milvus bernama kb_articles.
2. Masukkan data sampel (misalnya kebijakan pengembalian dana, kebijakan penukaran, waktu pengiriman).
3. Buat indeks HNSW untuk mempercepat pencarian.
- Membangun alat pencarian vektor
@p.tool
async def vector_search(query: str, top_k: int = 5, min_score: float = 0.35):
# 1. Convert user query into a vector
# 2. Perform similarity search in Milvus
# 3. Return results with relevance above threshold
- Mengonfigurasi Agen Parlant
Panduan 1: Untuk pertanyaan yang bersifat faktual atau terkait kebijakan, agen harus terlebih dahulu melakukan pencarian vektor.
Pedoman 2: Ketika bukti ditemukan, agen harus menjawab dengan menggunakan templat terstruktur (ringkasan + poin-poin penting + sumber).
# Guideline 1: Run vector search for factual or policy-related questions
await agent.create_guideline(
condition="User asks a factual question about policy, refund, exchange, or shipping",
action=(
"Call vector_search with the user's query. "
"If evidence is found, synthesize an answer by quoting key sentences and cite doc_id/title. "
"If evidence is insufficient, ask a clarifying question before answering."
),
tools=[vector_search],
# Guideline 2: Use a standardized, structured response when evidence is available
await agent.create_guideline(
condition=“Evidence is available”,
action=(
“Answer with the following template:\n”
“Summary: provide a concise conclusion.\n”
“Key points: 2-3 bullets distilled from evidence.\n”
“Sources: list doc_id and title.\n”
“Note: if confidence is low, state limitations and ask for clarification.”
),
tools=[],
)
tools=[],
)
- Tuliskan kode yang lengkap
import os
import asyncio
import json
from typing import List, Dict, Any
import parlant.sdk as p
from pymilvus import MilvusClient, DataType
# 1) Environment variables: using OpenAI (as both the default generation model and embedding service)
# Make sure the OPENAI_API_KEY is set
OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
if not OPENAI_API_KEY:
raise RuntimeError("Please set OPENAI_API_KEY environment variable")
# 2) Initialize Milvus Lite (runs locally, no standalone service required)
# MilvusClient runs in Lite mode using a local file path (requires pymilvus >= 2.x)
client = MilvusClient("./milvus_demo.db") # Lite mode uses a local file path
COLLECTION = "kb_articles"
# 3) Example data: three policy or FAQ entries (in practice, you can load and chunk data from files)
DOCS = [
{"doc_id": "POLICY-001", "title": "Refund Policy", "chunk": "Refunds are available within 30 days of purchase if the product is unused."},
{"doc_id": "POLICY-002", "title": "Exchange Policy", "chunk": "Exchanges are permitted within 15 days; original packaging required."},
{"doc_id": "FAQ-101", "title": "Shipping Time", "chunk": "Standard shipping usually takes 3–5 business days within the country."},
]
# 4) Generate embeddings using OpenAI (you can replace this with another embedding service)
# Here we use Parlant’s built-in OpenAI embedder for simplicity, but you could also call the OpenAI SDK directly.
class OpenAIEmbedder(p.Embedder):
async def embed(self, texts: List[str], hints: Dict[str, Any] = {}) -> p.EmbeddingResult:
# Generate text embeddings using the OpenAI API, with timeout and retry handling
import openai
try:
client = openai.AsyncOpenAI(
api_key=OPENAI_API_KEY,
timeout=60.0, # 60-second timeout
max_retries=2 # Retry up to 2 times
)
print(f"Generating embeddings for {len(texts)} texts...")
response = await client.embeddings.create(
model="text-embedding-3-small",
input=texts
)
vectors = [data.embedding for data in response.data]
print(f"Successfully generated {len(vectors)} embeddings.")
return p.EmbeddingResult(vectors=vectors)
except Exception as e:
print(f"OpenAI API call failed: {e}")
# Return mock vectors for testing Milvus connectivity
print("Using mock vectors for testing...")
import random
vectors = [[random.random() for _ in range(1536)] for _ in texts]
return p.EmbeddingResult(vectors=vectors)
@property
def id(self) -> str:
return "text-embedding-3-small"
@property
def max_tokens(self) -> int:
return 8192
@property
def tokenizer(self) -> p.EstimatingTokenizer:
from parlant.core.nlp.tokenization import ZeroEstimatingTokenizer
return ZeroEstimatingTokenizer()
@property
def dimensions(self) -> int:
return 1536
embedder = OpenAIEmbedder()
async def ensure_collection_and_load():
# Create the collection (schema: primary key, vector field, additional fields)
if not client.has_collection(COLLECTION):
client.create_collection(
collection_name=COLLECTION,
dimension=len((await embedder.embed(["dimension_probe"])).vectors[0]),
# Default metric: COSINE (can be changed with metric_type="COSINE")
auto_id=True,
)
# Create an index to speed up retrieval (HNSW used here as an example)
client.create_index(
collection_name=COLLECTION,
field_name="vector",
index_type="HNSW",
metric_type="COSINE",
params={"M": 32, "efConstruction": 200}
)
# Insert data (skip if already exists; simple idempotent logic for the demo)
# Generate embeddings
chunks = [d["chunk"] for d in DOCS]
embedding_result = await embedder.embed(chunks)
vectors = embedding_result.vectors
# Check if the same doc_id already exists; this is for demo purposes only — real applications should use stricter deduplication
# Here we insert directly. In production, use an upsert operation or an explicit primary key
client.insert(
COLLECTION,
data=[
{"vector": vectors[i], "doc_id": DOCS[i]["doc_id"], "title": DOCS[i]["title"], "chunk": DOCS[i]["chunk"]}
for i in range(len(DOCS))
],
)
# Load into memory
client.load_collection(COLLECTION)
# 5) Define the vector search tool (Parlant Tool)
@p.tool
async def vector_search(context: p.ToolContext, query: str, top_k: int = 5, min_score: float = 0.35) -> p.ToolResult:
# 5.1 Generate the query vector
embed_res = await embedder.embed([query])
qvec = embed_res.vectors[0]
# 5.2 Search Milvus
results = client.search(
collection_name=COLLECTION,
data=[qvec],
limit=top_k,
output_fields=["doc_id", "title", "chunk"],
search_params={"metric_type": "COSINE", "params": {"ef": 128}},
)
# 5.3 Assemble structured evidence and filter by score threshold
hits = []
for hit in results[0]:
score = hit["distance"] if "distance" in hit else hit.get("score", 0.0)
if score >= min_score:
hits.append({
"doc_id": hit["entity"]["doc_id"],
"title": hit["entity"]["title"],
"chunk": hit["entity"]["chunk"],
"score": float(score),
})
return p.ToolResult({"evidence": hits})
# 6) Run Parlant Server and create the Agent + Guidelines
async def main():
await ensure_collection_and_load()
async with p.Server() as server:
agent = await server.create_agent(
name="Policy Assistant",
description="Rule-controlled RAG assistant with Milvus Lite",
)
# Example variable: current time (can be used in templates or logs)
@p.tool
async def get_datetime(context: p.ToolContext) -> p.ToolResult:
from datetime import datetime
return p.ToolResult({"now": datetime.now().isoformat()})
await agent.create_variable(name="current-datetime", tool=get_datetime)
# Core Guideline 1: Run vector search for factual or policy-related questions
await agent.create_guideline(
condition="User asks a factual question about policy, refund, exchange, or shipping",
action=(
"Call vector_search with the user's query. "
"If evidence is found, synthesize an answer by quoting key sentences and cite doc_id/title. "
"If evidence is insufficient, ask a clarifying question before answering."
),
tools=[vector_search],
)
# Core Guideline 2: Use a standardized, structured response when evidence is available
await agent.create_guideline(
condition="Evidence is available",
action=(
"Answer with the following template:\\n"
"Summary: provide a concise conclusion.\\n"
"Key points: 2-3 bullets distilled from evidence.\\n"
"Sources: list doc_id and title.\\n"
"Note: if confidence is low, state limitations and ask for clarification."
),
tools=[],
)
# Hint: Local Playground URL
print("Playground: <http://localhost:8800>")
if __name__ == "__main__":
asyncio.run(main())
Langkah 4: Jalankan Kode
# Run the main program
python main.py
- Kunjungi Taman Bermain:
<http://localhost:8800>
Anda sekarang telah berhasil membangun sistem Tanya Jawab cerdas menggunakan Parlant dan Milvus.
Parlant vs LangChain/LlamaIndex: Bagaimana Mereka Berbeda dan Bagaimana Mereka Bekerja Bersama
Dibandingkan dengan kerangka kerja agen yang sudah ada seperti LangChain atau LlamaIndex, apa perbedaan Parlant?
LangChain dan LlamaIndex adalah kerangka kerja tujuan umum. Mereka menyediakan berbagai macam komponen dan integrasi, sehingga ideal untuk pembuatan prototipe dan eksperimen penelitian yang cepat. Namun, ketika harus menerapkan dalam produksi, pengembang sering kali perlu membangun lapisan ekstra sendiri - seperti manajemen aturan, pemeriksaan kepatuhan, dan mekanisme keandalan - untuk menjaga agar agen tetap konsisten dan dapat dipercaya.
Parlant menawarkan Manajemen Pedoman bawaan, mekanisme kritik diri, dan alat penjelasan yang membantu pengembang mengelola bagaimana agen berperilaku, merespons, dan memberi alasan. Hal ini membuat Parlant sangat cocok untuk kasus penggunaan yang berisiko tinggi dan berhadapan langsung dengan pelanggan yang membutuhkan akurasi dan akuntabilitas, seperti keuangan, perawatan kesehatan, dan layanan hukum.
Bahkan, kerangka kerja ini dapat bekerja bersama:
Gunakan LangChain untuk membangun jalur pemrosesan data yang kompleks atau alur kerja pengambilan data.
Gunakan Parlant untuk mengelola lapisan interaksi akhir, memastikan keluaran mengikuti aturan bisnis dan tetap dapat diinterpretasikan.
Gunakan Milvus sebagai fondasi basis data vektor untuk memberikan pencarian semantik, memori, dan pengambilan pengetahuan secara real-time di seluruh sistem.
Kesimpulan
Ketika agen LLM beralih dari eksperimen ke produksi, pertanyaan kuncinya bukan lagi apa yang dapat mereka lakukan-tetapi seberapa andal dan aman mereka dapat melakukannya. Parlant menyediakan struktur dan kontrol untuk keandalan tersebut, sementara Milvus memberikan infrastruktur vektor yang dapat diskalakan yang membuat semuanya berjalan dengan cepat dan sesuai dengan konteks.
Bersama-sama, keduanya memungkinkan pengembang untuk membangun agen AI yang tidak hanya mampu, tetapi juga dapat dipercaya, dapat dijelaskan, dan siap produksi.
🚀 Lihat Parlant di GitHub dan integrasikan dengan Milvus untuk membangun sistem agen cerdas yang digerakkan oleh aturan Anda sendiri.
Punya 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 Milvus Office Hours.
Try Managed Milvus for Free
Zilliz Cloud is hassle-free, powered by Milvus and 10x faster.
Get StartedLike the article? Spread the word
