LangChain / RAG / Vector DBs · Pelajaran

Membangun Pengurai Keluaran Kustom

Ubah teks mentah LLM menjadi data terstruktur yang andal dengan pengurai keluaran kustom dan bawaan LangChain.

Membangun Pengurai Keluaran Kustom adalah pelajaran LangChain / RAG / Vector DBs gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar LangChain / RAG / Vector DBs, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus LangChain / RAG / Vector DBs mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

Why Parse Output?

LLMs return free-form text, but applications need structured data: objects, lists, enums. An output parser converts the raw string into something your code can use safely.

The Parser Interface

A LangChain output parser implements two key methods.

parse(text) turns the string into your type
get_format_instructions() tells the model how to format its reply

A Minimal Custom Parser

Subclass BaseOutputParser and implement parse. This one splits a comma-separated reply into a list.

from langchain_core.output_parsers import BaseOutputParser

class CommaListParser(BaseOutputParser):
    def parse(self, text):
        return [t.strip() for t in text.split(",")]

print(CommaListParser().parse("a, b, c"))  # ["a", "b", "c"]

Format Instructions

Override get_format_instructions so the prompt nudges the model toward a parseable shape. The instructions are injected into your prompt template.

def get_format_instructions(self):
    return "Reply with items separated by commas, no numbering."

Pydantic Output Parser

For rich objects, LangChain ships a PydanticOutputParser. You define a schema and it generates instructions plus validation automatically.

from pydantic import BaseModel

class Person(BaseModel):
    name: str
    age: int

# parser = PydanticOutputParser(pydantic_object=Person)

Wiring a Parser into a Chain

With LCEL you pipe the model output straight into the parser using the | operator.

chain = prompt | llm | CommaListParser()
result = chain.invoke({"topic": "fruits"})

Handling Malformed Output

Models sometimes ignore the format. A robust parser validates and raises a clear error, or attempts a best-effort recovery, instead of crashing downstream.

def parse(self, text):
    try:
        return json.loads(text)
    except json.JSONDecodeError:
        raise ValueError("Model did not return valid JSON")

The OutputFixingParser

Wrap any parser in an OutputFixingParser. When parsing fails, it sends the bad output and the error back to an LLM to repair it.

Streaming and Parsers

Some parsers support incremental parsing of streamed tokens. For structured types this is hard, so streaming parsers often emit partial objects as fields complete.

Validation Beyond Types

You can add business rules inside parse: ranges, allowed values, required combinations. Reject anything that would corrupt your application state.

def parse(self, text):
    n = int(text.strip())
    if not 1 <= n <= 5:
        raise ValueError("Rating must be 1-5")
    return n

Putting It Together

Define the parser, expose format instructions, inject them into the prompt, and pipe everything in a chain. The result is reliable structured output.

prompt = template.partial(
    format=parser.get_format_instructions()
)
chain = prompt | llm | parser
chain.invoke({"input": "..."})

Quick Check

Test your understanding of output parsers.

Recap

You built custom output parsing:

Implement parse and get_format_instructions
Use PydanticOutputParser for rich schemas
Pipe parsers into chains with |
Wrap with OutputFixingParser for resilience

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Membangun Pengurai Keluaran Kustom” gratis?

Ya — teks lengkap “Membangun Pengurai Keluaran Kustom” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus LangChain / RAG / Vector DBs, upgrade ke CoddyKit PRO. Kursus LangChain / RAG / Vector DBs mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Membangun Pengurai Keluaran Kustom”?

Ubah teks mentah LLM menjadi data terstruktur yang andal dengan pengurai keluaran kustom dan bawaan LangChain. Kamu berlatih LangChain / RAG / Vector DBs dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai LangChain / RAG / Vector DBs?

Tidak diperlukan pengalaman sebelumnya. LangChain / RAG / Vector DBs di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Membangun Pengurai Keluaran Kustom” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran LangChain / RAG / Vector DBs ini?

Ya. Setiap pelajaran LangChain / RAG / Vector DBs menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Mengembangkan Pemuat Dokumen Kustom
Mengintegrasikan Model Embedding Kustom
Memperluas Rantai Retrieval dengan Logika Kustom
Membangun Pengurai Keluaran Kustom

← Kembali ke LangChain / RAG / Vector DBs