Architettura di LangChain e astrazioni fondamentali
Comprenderà il modello a componenti di LangChain, inclusi LLM, ChatModels, PromptTemplates, OutputParsers e Runnables, e il modo in cui si combinano nelle pipeline.
Architettura di LangChain e astrazioni fondamentali è una lezione AI Engineering Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Engineering Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Engineering Academy include 4 lezioni in totale.
Che cos'è realmente LangChain
LangChain è un framework per creare applicazioni basate su modelli linguistici. Invece di scrivere autonomamente chiamate API grezze e codice di collegamento, LangChain fornisce componenti riutilizzabili che si combinano in pipeline. Supporta diversi provider LLM (OpenAI, Anthropic, Cohere, modelli locali) tramite un'interfaccia unificata, quindi il passaggio da un provider all'altro richiede modifiche minime al codice.
Panoramica del modello a componenti
LangChain organizza i propri blocchi di costruzione in categorie di componenti distinte. LLMs e ChatModels fungono da wrapper per i provider dei modelli. PromptTemplates gestiscono la costruzione dinamica dei prompt. OutputParsers trasformano il testo grezzo del modello in oggetti Python strutturati. I Runnables sono l'interfaccia universale che collega tutto in pipeline componibili.
LLM e ChatModels a confronto
LangChain distingue due interfacce per i modelli. LLM accetta un prompt sotto forma di stringa e restituisce un completamento sotto forma di stringa, secondo il vecchio stile del completamento testuale. ChatModel accetta un elenco di messaggi (system, human, AI) e restituisce un oggetto messaggio. I moderni modelli OpenAI, Anthropic e Gemini sono tutti ChatModel. Per le nuove applicazioni è preferibile usare ChatModel.
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage
llm = ChatOpenAI(model='gpt-4o-mini')
response = llm.invoke([
SystemMessage(content='You are a helpful assistant.'),
HumanMessage(content='What is LangChain?')
])
print(response.content)PromptTemplates: prompt dinamici
PromptTemplate consente di definire un prompt con variabili segnaposto che vengono valorizzate in fase di esecuzione. ChatPromptTemplate fa lo stesso per i prompt in stile chat con più messaggi. I template separano la struttura del prompt dai valori di runtime, rendendo i prompt riutilizzabili, testabili e facili da gestire con il controllo versione.
from langchain_core.prompts import ChatPromptTemplate
template = ChatPromptTemplate.from_messages([
('system', 'You are an expert in {domain}.'),
('human', 'Explain {concept} in simple terms.')
])
# Fill in variables at runtime
messages = template.invoke({'domain': 'machine learning', 'concept': 'embeddings'})
print(messages)OutputParsers: strutturare l'output del modello
OutputParsers converte l'output grezzo sotto forma di stringa di un modello in tipi Python strutturati. StrOutputParser estrae semplicemente la stringa del contenuto. JsonOutputParser analizza il JSON. PydanticOutputParser convalida i dati rispetto a uno schema Pydantic. I parser generano anche istruzioni sul formato che è possibile inserire nei prompt per guidare il modello verso il formato previsto.
from langchain_core.output_parsers import StrOutputParser, JsonOutputParser
from pydantic import BaseModel
class MovieReview(BaseModel):
title: str
rating: int
summary: str
parser = JsonOutputParser(pydantic_object=MovieReview)
# parser.get_format_instructions() returns JSON schema instructions
print(parser.get_format_instructions()[:200])L'interfaccia Runnable
Ogni componente LangChain implementa l'interfaccia Runnable, che definisce tre metodi fondamentali: invoke() per le singole chiamate sincrone, stream() per lo streaming token per token e batch() per elaborare più input in parallelo. Poiché ogni componente è un Runnable, è possibile comporli tutti in modo uniforme usando l'operatore pipe.
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model='gpt-4o-mini')
# Single call
result = llm.invoke('What is 2+2?')
# Streaming tokens
for chunk in llm.stream('Tell me a joke.'):
print(chunk.content, end='', flush=True)
# Batch processing
results = llm.batch(['What is Paris?', 'What is Rome?'])Comporre con l'operatore pipe
L'operatore pipe (|) è una scorciatoia sintattica per creare oggetti RunnableSequence. Quando si scrive prompt | llm | parser, LangChain crea una catena in cui l'output di ogni passaggio confluisce nell'input del successivo. Questo è il cuore di LCEL — LangChain Expression Language — e sostituisce le precedenti classi Chain, più verbose.
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_template('Summarize this in one sentence: {text}')
llm = ChatOpenAI(model='gpt-4o-mini')
parser = StrOutputParser()
# Chain composed with pipe operator
chain = prompt | llm | parser
result = chain.invoke({'text': 'LangChain is a framework for LLM applications...'})
print(result)Caricatori di documenti e suddivisori di testo
Per le applicazioni RAG, LangChain fornisce Document Loaders che leggono file in vari formati (PDF, Word, HTML, CSV) e restituiscono un elenco di oggetti Document con i campi page_content e metadata. Gli Text Splitters dividono poi i documenti lunghi in chunk più piccoli, adatti all'embedding e al recupero.
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
loader = PyPDFLoader('report.pdf')
docs = loader.load() # List of Document objects
splitter = RecursiveCharacterTextSplitter(
chunk_size=500,
chunk_overlap=50
)
chunks = splitter.split_documents(docs)
print(f'Split {len(docs)} pages into {len(chunks)} chunks')I vector store come Runnable
LangChain integra i database vettoriali (Chroma, Pinecone, pgvector) come oggetti VectorStore che espongono un metodo similarity_search(). È possibile convertire qualsiasi VectorStore in un Runnable Retriever con .as_retriever(), rendendolo componibile nelle catene LCEL. Il retriever accetta una stringa di query e restituisce i documenti più rilevanti, fino a k risultati.
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(chunks, embeddings)
# Convert to Retriever Runnable
retriever = vectorstore.as_retriever(
search_type='similarity',
search_kwargs={'k': 5}
)
results = retriever.invoke('How does LangChain work?')
for doc in results:
print(doc.page_content[:100])Callback e osservabilità
Il sistema di callback di LangChain consente di collegarsi a ogni evento dell'esecuzione di una catena: quando un LLM viene avviato, quando vengono trasmessi i token, quando una catena termina e quando viene chiamato uno strumento. Tra i callback integrati c'è StdOutCallbackHandler per registrare i messaggi nella console. Le integrazioni di terze parti come LangSmith si collegano automaticamente tramite variabili d'ambiente e acquisiscono le tracce complete dell'esecuzione senza modifiche al codice.
from langchain.callbacks import StdOutCallbackHandler
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model='gpt-4o-mini',
callbacks=[StdOutCallbackHandler()]
)
# Now every call logs input/output automatically
# Or enable LangSmith tracing globally:
import os
os.environ['LANGCHAIN_TRACING_V2'] = 'true'
os.environ['LANGCHAIN_API_KEY'] = 'your-key'Memoria e stato nelle catene
Per impostazione predefinita, le catene LangChain sono stateless, ovvero ogni invocazione è indipendente. Per aggiungere la memoria conversazionale, si avvolge una catena con un componente di memoria che memorizza e inserisce la cronologia della conversazione. RunnableWithMessageHistory è il modo nativo di LCEL per aggiungere la memoria e accetta una funzione get_session_history che carica la cronologia in base all'ID della sessione.
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain_community.chat_message_histories import ChatMessageHistory
store = {} # session_id -> ChatMessageHistory
def get_session_history(session_id: str):
if session_id not in store:
store[session_id] = ChatMessageHistory()
return store[session_id]
with_history = RunnableWithMessageHistory(chain, get_session_history)
response = with_history.invoke(
{'input': 'Hi, my name is Alice'},
config={'configurable': {'session_id': 'user-1'}}
)Verifica rapida
Verifichi la Sua comprensione dell'architettura e delle astrazioni fondamentali di LangChain.
Riepilogo della lezione
In questa lezione ha imparato che: il modello a componenti di LangChain organizza LLM, PromptTemplates, OutputParsers e Retrievers come Runnable dotati di un'interfaccia unificata; l'operatore pipe (|) compone i Runnable in catene sequenziali tramite LCEL; e i callback consentono l'osservabilità a ogni passaggio senza modificare la logica di business. Ora approfondiremo la creazione di catene con LCEL.
Domande Frequenti
La lezione «Architettura di LangChain e astrazioni fondamentali» è gratuita?
Sì — il testo completo di «Architettura di LangChain e astrazioni fondamentali» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Engineering Academy, passa a CoddyKit PRO. Il corso AI Engineering Academy include 4 lezioni in totale.
Cosa imparerò in «Architettura di LangChain e astrazioni fondamentali»?
Comprenderà il modello a componenti di LangChain, inclusi LLM, ChatModels, PromptTemplates, OutputParsers e Runnables, e il modo in cui si combinano nelle pipeline. Eserciti AI Engineering Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare AI Engineering Academy?
Non è richiesta alcuna esperienza precedente. AI Engineering Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.
Quanto tempo richiede la lezione «Architettura di LangChain e astrazioni fondamentali»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione AI Engineering Academy?
Sì. Ogni lezione AI Engineering Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Architettura di LangChain e astrazioni fondamentali
- Creare chain con LCEL
- Chain ramificate e parallele
- Streaming dell'output in LangChain