Dasar-Dasar LangChain dan LlamaIndex
Mulailah menggunakan kerangka kerja canggih seperti LangChain dan LlamaIndex untuk membangun aplikasi LLM kompleks dengan mudah.
Dasar-Dasar LangChain dan LlamaIndex adalah pelajaran Prompt Engineering & LLM Optimization for Developers gratis di CoddyKit. Ini adalah pelajaran 2 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 Prompt Engineering & LLM Optimization for Developers, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Prompt Engineering & LLM Optimization for Developers mencakup 4 pelajaran total.
Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.
Why Use LLM Frameworks?
Working directly with Large Language Model (LLM) APIs can be like building with raw LEGO bricks. It's powerful, but complex for bigger projects.
Frameworks like LangChain and LlamaIndex provide pre-built tools and structures. They simplify common tasks, making it much easier to build sophisticated LLM applications.
LangChain: Orchestrating LLMs
LangChain is a framework designed to help you build applications with LLMs by "chaining" together different components.
- It provides abstractions for working with various LLMs.
- It enables complex workflows involving multiple steps.
- Think of it as the glue for your LLM-powered application logic.
Core LangChain Components
LangChain organizes functionality into key modules:
- LLMs: Wrappers for different LLM providers (e.g., OpenAI, Anthropic).
- Prompts: Templates to easily construct dynamic prompts.
- Chains: Sequences of calls to LLMs or other utilities.
- Agents: LLMs that decide which tools to use and in what order.
- Memory: For persistent state in conversational applications.
Your First LangChain Idea
Let's see how a simple prompt and a mock LLM can work together. This example shows how LangChain conceptualizes connecting a prompt template to an LLM, even with a simulated model.
from langchain_core.prompts import PromptTemplate
from langchain_core.language_models import BaseChatModel
from langchain_core.messages import BaseMessage, HumanMessage, AIMessage
# A simple mock LLM for demonstration
class MockChatModel(BaseChatModel):
def _generate(self, messages, stop=None, run_manager=None):
last_message_content = messages[-1].content
response = f"Mock response for: '{last_message_content}'"
return AIMessage(content=response)
@property
def _llm_type(self) -> str:
return "mock_chat_model"
def main():
# 1. Define a Prompt Template
template = "Tell me a fun fact about {topic}."
prompt = PromptTemplate(template=template, input_variables=["topic"])
# 2. Instantiate our Mock LLM
llm = MockChatModel()
# 3. Format the prompt with input
formatted_prompt = prompt.format(topic="penguins")
print("--- Formatted Prompt ---")
print(formatted_prompt)
# 4. Invoke the LLM (simulated)
# In a real LangChain app, you'd use a chain, but this shows the core interaction.
response_message = llm.invoke([HumanMessage(content=formatted_prompt)])
print("\n--- Mock LLM Response ---")
print(response_message.content)
if __name__ == "__main__":
main()LlamaIndex: Data & LLMs
LlamaIndex is a data framework designed to connect your custom data sources to LLMs. Its primary goal is to make it easy to build applications that can query and understand your own private or domain-specific data.
- Focuses on data ingestion, indexing, and retrieval.
- Powers Retrieval Augmented Generation (RAG) applications.
- Helps LLMs answer questions beyond their training data.
Core LlamaIndex Concepts
LlamaIndex streamlines the RAG pipeline with these components:
- Documents: Raw data inputs (e.g., text files, PDFs, database records).
- Nodes: Chunks of text derived from Documents, often with associated metadata.
- Indexes: Data structures (like vector stores) that organize Nodes for efficient retrieval.
- Query Engines: Interfaces for querying an index, often combining retrieval and LLM synthesis.
Querying Custom Data (Simulated)
Here's a simplified look at how LlamaIndex connects data to a query. We simulate ingesting a document and then querying it, demonstrating the core retrieval idea.
class Document:
def __init__(self, text, doc_id=None):
self.text = text
self.doc_id = doc_id if doc_id else f"doc_{hash(text)}"
class MockVectorStore:
def __init__(self):
self.store = {}
self.documents = []
def add(self, docs):
for doc in docs:
self.store[doc.doc_id] = doc.text
self.documents.append(doc)
def query(self, query_text):
for doc in self.documents:
if query_text.lower() in doc.text.lower():
return [doc.text]
return []
class MockQueryEngine:
def __init__(self, vector_store):
self.vector_store = vector_store
def query(self, query_text):
retrieved_texts = self.vector_store.query(query_text)
if retrieved_texts:
return f"Based on available info, for '{query_text}': {retrieved_texts[0]}"
return f"Could not find specific information for '{query_text}'."
def main():
# 1. Simulate Documents
documents = [
Document("The quick brown fox jumps over the lazy dog."),
Document("Cats love to nap in sunny spots."),
Document("Python is a popular programming language.")
]
# 2. Simulate building a Vector Store and Index
mock_store = MockVectorStore()
mock_store.add(documents)
# 3. Create a Query Engine
query_engine = MockQueryEngine(mock_store)
# 4. Query the data
response1 = query_engine.query("What is Python?")
print("--- Query 1 Response ---")
print(response1)
response2 = query_engine.query("What about foxes?")
print("\n--- Query 2 Response ---")
print(response2)
response3 = query_engine.query("What is the capital of France?")
print("\n--- Query 3 Response ---")
print(response3)
if __name__ == "__main__":
main()LangChain vs. LlamaIndex
While both frameworks help with LLMs, their primary focus differs:
- LangChain: Best for orchestrating complex LLM workflows, building agents, conversational bots, and integrating various tools.
- LlamaIndex: Ideal for data-intensive LLM applications, especially when you need to connect LLMs to your private or domain-specific data for RAG.
Often, you'll find them complementing each other in real-world applications.
Synergy: LangChain + LlamaIndex
It's common to use LangChain and LlamaIndex together for powerful applications:
- Use LlamaIndex to ingest, index, and retrieve relevant information from your data sources.
- Pass the retrieved context to LangChain, which then uses its "chains" or "agents" to process this context with an LLM, refine answers, or interact with other tools.
This combines LlamaIndex's data prowess with LangChain's orchestration capabilities.
Framework Roles
Consider the core strengths of LangChain and LlamaIndex. Which of the following statements accurately describe their primary roles or common use cases?
Lesson Recap
In this lesson, we explored LangChain and LlamaIndex, two powerful frameworks for building LLM applications.
- LangChain helps orchestrate complex LLM workflows, chains, and agents.
- LlamaIndex specializes in connecting LLMs to your custom data for efficient retrieval and RAG.
- These frameworks often work together, with LlamaIndex providing data context to LangChain's reasoning.
Understanding their distinct roles will help you choose the right tool for your next LLM project!
Belajar Prompt Engineering & LLM Optimization for Developers dengan tutor AI — gratis
Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.
- Kursus
- 12
- Pelajaran
- 48
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Dasar-Dasar LangChain dan LlamaIndex” gratis?
Ya — teks lengkap “Dasar-Dasar LangChain dan LlamaIndex” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Prompt Engineering & LLM Optimization for Developers, upgrade ke CoddyKit PRO. Kursus Prompt Engineering & LLM Optimization for Developers mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Dasar-Dasar LangChain dan LlamaIndex”?
Mulailah menggunakan kerangka kerja canggih seperti LangChain dan LlamaIndex untuk membangun aplikasi LLM kompleks dengan mudah. Kamu berlatih Prompt Engineering & LLM Optimization for Developers 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 Prompt Engineering & LLM Optimization for Developers?
Tidak diperlukan pengalaman sebelumnya. Prompt Engineering & LLM Optimization for Developers 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 2 dari 4.
Berapa lama pelajaran “Dasar-Dasar LangChain dan LlamaIndex” 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 Prompt Engineering & LLM Optimization for Developers ini?
Ya. Setiap pelajaran Prompt Engineering & LLM Optimization for Developers 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
- Interaksi API LLM (OpenAI, Anthropic)
- Dasar-Dasar LangChain dan LlamaIndex
- Pengelolaan dan Penerapan Versi Perintah
- Dasar-Dasar Retrieval-Augmented Generation (RAG)