LangChain & LlamaIndex Basics
Get started with powerful frameworks like LangChain and LlamaIndex for building complex LLM applications with ease.
LangChain & LlamaIndex Basics is a free Prompt Engineering & LLM Optimization for Developers lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Prompt Engineering & LLM Optimization for Developers learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.
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!
Frequently asked questions
Is the “LangChain & LlamaIndex Basics” lesson free?
Yes — the full text of “LangChain & LlamaIndex Basics” is free to read here on the web, and the Prompt Engineering & LLM Optimization for Developers course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Prompt Engineering & LLM Optimization for Developers course, upgrade to CoddyKit PRO.
What will I learn in “LangChain & LlamaIndex Basics”?
Get started with powerful frameworks like LangChain and LlamaIndex for building complex LLM applications with ease. You practise Prompt Engineering & LLM Optimization for Developers with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start Prompt Engineering & LLM Optimization for Developers?
No prior experience is required. Prompt Engineering & LLM Optimization for Developers on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.
How long does the “LangChain & LlamaIndex Basics” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this Prompt Engineering & LLM Optimization for Developers lesson?
Yes. Every Prompt Engineering & LLM Optimization for Developers lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.
All lessons in this course
- LLM API Interaction (OpenAI, Anthropic)
- LangChain & LlamaIndex Basics
- Prompt Management & Versioning
- Retrieval-Augmented Generation (RAG) Basics