Grundlæggende om LangChain og LlamaIndex
Kom i gang med effektive frameworks som LangChain og LlamaIndex til nemt at bygge komplekse LLM-applikationer.
Grundlæggende om LangChain og LlamaIndex er en gratis Promptdesign og optimering af LLM'er for udviklere-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Promptdesign og optimering af LLM'er for udviklere, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Promptdesign og optimering af LLM'er for udviklere-kurset indeholder 4 lektioner i alt.
Hvorfor bruge LLM-frameworks?
At arbejde direkte med API'er til Large Language Models (LLM'er) kan sammenlignes med at bygge med løse LEGO-klodser. Det er effektivt, men komplekst i større projekter.
Frameworks som LangChain og LlamaIndex tilbyder færdige værktøjer og strukturer. De forenkler almindelige opgaver og gør det meget nemmere at bygge avancerede LLM-applikationer.
LangChain: Orkestrering af LLM'er
LangChain er et framework, der er udviklet til at hjælpe dig med at bygge applikationer med LLM'er ved at "kæde" forskellige komponenter sammen.
- Det tilbyder abstraktioner til arbejde med forskellige LLM'er.
- Det muliggør komplekse arbejdsgange, der består af flere trin.
- Se det som limen i logikken bag din LLM-drevne applikation.
Centrale LangChain-komponenter
LangChain organiserer funktionaliteten i centrale moduler:
- LLMs: Indpakninger til forskellige LLM-udbydere (f.eks. OpenAI, Anthropic).
- Prompts: Skabeloner til nem opbygning af dynamiske prompts.
- Chains: Sekvenser af kald til LLM'er eller andre hjælpeværktøjer.
- Agents: LLM'er, der beslutter, hvilke værktøjer der skal bruges, og i hvilken rækkefølge.
- Memory: Til vedvarende tilstand i samtalebaserede applikationer.
Din første LangChain-idé
Lad os se, hvordan en simpel prompt og en simuleret LLM kan arbejde sammen. Dette eksempel viser, hvordan LangChain konceptualiserer forbindelsen mellem en promptskabelon og en LLM, selv med en simuleret 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 og LLM'er
LlamaIndex er et dataframework, der er udviklet til at forbinde dine egne datakilder med LLM'er. Det primære mål er at gøre det nemt at bygge applikationer, der kan forespørge i og forstå dine egne private eller domænespecifikke data.
- Fokuserer på dataindlæsning, indeksering og hentning.
- Driver Retrieval Augmented Generation-applikationer (RAG).
- Hjælper LLM'er med at besvare spørgsmål, der ligger uden for deres træningsdata.
Centrale LlamaIndex-koncepter
LlamaIndex effektiviserer RAG-pipelinen med disse komponenter:
- Documents: Rå datainput (f.eks. tekstfiler, PDF'er og databaseposter).
- Nodes: Tekststykker, der er udledt af Documents, ofte med tilknyttede metadata.
- Indexes: Datastrukturer (f.eks. vektorlager), der organiserer Nodes, så de kan hentes effektivt.
- Query Engines: Grænseflader til forespørgsler i et indeks, ofte ved at kombinere hentning og syntese med en LLM.
Forespørgsler i egne data (simuleret)
Her får du et forenklet indblik i, hvordan LlamaIndex forbinder data med en forespørgsel. Vi simulerer indlæsning af et dokument og forespørger derefter i det for at demonstrere det grundlæggende princip for hentning.
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 sammenlignet med LlamaIndex
Selvom begge frameworks hjælper med LLM'er, er deres primære fokus forskelligt:
- LangChain: Bedst til orkestrering af komplekse LLM-arbejdsgange, opbygning af agenter og samtalebots samt integration af forskellige værktøjer.
- LlamaIndex: Ideelt til dataintensive LLM-applikationer, især når du har brug for at forbinde LLM'er med dine private eller domænespecifikke data til RAG.
Ofte vil du se dem supplere hinanden i virkelige applikationer.
Synergi: LangChain + LlamaIndex
Det er almindeligt at bruge LangChain og LlamaIndex sammen til effektive applikationer:
- Brug LlamaIndex til at indlæse, indeksere og hente relevante oplysninger fra dine datakilder.
- Send den hentede kontekst til LangChain, som derefter bruger sine "chains" eller "agents" til at behandle konteksten med en LLM, forbedre svar eller interagere med andre værktøjer.
På den måde kombineres LlamaIndex' stærke datafunktioner med LangChains orkestreringsmuligheder.
Frameworks' roller
Overvej LangChains og LlamaIndex' centrale styrker. Hvilke af følgende udsagn beskriver korrekt deres primære roller eller almindelige anvendelsesområder?
Opsummering af lektionen
I denne lektion har vi udforsket LangChain og LlamaIndex, to effektive frameworks til at bygge LLM-applikationer.
- LangChain hjælper med at orkestrere komplekse LLM-arbejdsgange, chains og agents.
- LlamaIndex er specialiseret i at forbinde LLM'er med dine egne data, så de effektivt kan hentes og bruges til RAG.
- Disse frameworks arbejder ofte sammen, hvor LlamaIndex leverer datakontekst til LangChains ræsonnering.
Hvis du forstår deres forskellige roller, bliver det nemmere at vælge det rigtige værktøj til dit næste LLM-projekt!
Lær Promptdesign og optimering af LLM'er for udviklere med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 12
- Lektioner
- 48
Ofte stillede spørgsmål
Er lektionen “Grundlæggende om LangChain og LlamaIndex” gratis?
Ja — hele teksten til “Grundlæggende om LangChain og LlamaIndex” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Promptdesign og optimering af LLM'er for udviklere-kurset, skal du opgradere til CoddyKit PRO. Promptdesign og optimering af LLM'er for udviklere-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Grundlæggende om LangChain og LlamaIndex”?
Kom i gang med effektive frameworks som LangChain og LlamaIndex til nemt at bygge komplekse LLM-applikationer. Du øver dig i Promptdesign og optimering af LLM'er for udviklere med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Promptdesign og optimering af LLM'er for udviklere?
Der kræves ingen tidligere erfaring. Promptdesign og optimering af LLM'er for udviklere på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.
Hvor lang tid tager lektionen “Grundlæggende om LangChain og LlamaIndex”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Promptdesign og optimering af LLM'er for udviklere-lektion?
Ja. Alle Promptdesign og optimering af LLM'er for udviklere-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Interaktion med LLM-API'er (OpenAI, Anthropic)
- Grundlæggende om LangChain og LlamaIndex
- Promptstyring og versionshåndtering
- Grundlæggende Retrieval-Augmented Generation (RAG)