Hai un prompt che cambia ogni volta in base ai dati del tuo cliente? Estrarre informazioni strutturate dal testo che un LLM ti restituisce è un incubo di parsing manuale? Noi, di Meteora Web, ci siamo passati. E dopo 8 anni a costruire piattaforme per aziende reali, abbiamo imparato che senza chain, prompt template e output parser ogni integrazione con un LLM diventa un bordello ingovernabile.
Questa guida è per chi ha già visto un modello generare testo. Ora vogliamo che quel testo diventi un dato utilizzabile: JSON, enum, lista, data. E che il prompt sia riutilizzabile senza copia-incolla ogni volta.
Partiamo dal problema concreto: devi chiamare un LLM e ottenere un array di oggetti con nome, prezzo e categoria. Se fai un parsing a mano con regex, quando il modello cambia formulazione il tuo codice si rompe. Ecco perché esistono gli output parser.
Perché prompt template e output parser non sono optional
Un LLM vede solo stringhe. Ma la tua logica di business lavora con oggetti, array, enumerazioni. Senza un parser, ogni risposta va trattata come testo grezzo: scrivere regex fragili, gestire eccezioni, sperare che il modello rispetti il formato. È inefficiente e fragile. Noi lo vediamo ogni giorno nei progetti che ci arrivano: codice pieno di split(",") e json.loads senza gestione errori.
I prompt template invece ti evitano di costruire stringhe con concatenazione manuale: variabili, f-string e altri trucchi funzionano, ma diventano illeggibili quando il prompt supera le 10 righe. Un template separa la struttura fissa dalla parte variabile, e supporta formati come f-string o jinja2.
Le basi: da prompt grezzo a template strutturato
LangChain offre PromptTemplate e ChatPromptTemplate. Noi usiamo quasi sempre quest'ultimo perché nei progetti reali i modelli di chat (gpt-4, claude, gemini) rispondono meglio a messaggi strutturati (system, user, assistant).
PromptTemplate semplice
from langchain.prompts import PromptTemplate
template = """Traduci la seguente frase in francese:
Frase: {frase}
Traduzione:"""
prompt = PromptTemplate(input_variables=["frase"], template=template)
print(prompt.format(frase="Ciao mondo"))Output: la stringa pronta per essere inviata. Semplice, ma ha un limite: non gestisce messaggi di sistema separati.
ChatPromptTemplate per conversazioni reali
Quando usi modelli chat, il prompt è una lista di messaggi. Ecco come si fa:
from langchain.prompts import ChatPromptTemplate
from langchain.schema import SystemMessage, HumanMessage
template = ChatPromptTemplate.from_messages([
("system", "Sei un assistente esperto di cucina italiana."),
("human", "Dimmi una ricetta per {piatto}.")
])
messages = template.format_messages(piatto="carbonara")
print(messages)I messaggi sono oggetti che LangChain passerà direttamente al modello.
Template parziali
Spesso hai variabili fisse per più chiamate (es. la lingua di output). Invece di passarla ogni volta, usa partial variables:
partial = template.partial(lingua="italiano")
# ora puoi chiamare format senza specificare lingua
print(partial.format(prodotto="caffè"))Output Parser: trasformare testo in dati
Il parser fa il lavoro sporco al posto tuo. LangChain ne ha di predefiniti, ma puoi creare i tuoi ereditando da BaseOutputParser.
PydanticOutputParser
Il nostro preferito: dichiari un modello Pydantic, e il parser genera le istruzioni per il modello e poi valida il JSON in uscita.
from langchain.output_parsers import PydanticOutputParser
from pydantic import BaseModel, Field
class Prodotto(BaseModel):
nome: str = Field(description="Nome del prodotto")
prezzo: float = Field(description="Prezzo in euro")
categoria: str = Field(description="Categoria merceologica")
parser = PydanticOutputParser(pydantic_object=Prodotto)
# Otteniamo le istruzioni per il prompt
istruzioni = parser.get_format_instructions()
print(istruzioni)Le istruzioni dicono al modello di restituire un JSON con quei campi. Poi, quando ottieni la risposta:
risposta_llm = '{"nome": "Caffè Arabica", "prezzo": 12.50, "categoria": "Bevande"}'
prodotto = parser.parse(risposta_llm)
print(prodotto.nome) # Caffè ArabicaSe il JSON è malformato o mancano campi, parse lancia un errore. Gestiscilo con un try-except.
CommaSeparatedListOutputParser
Utile per liste semplici:
from langchain.output_parsers import CommaSeparatedListOutputParser
parser = CommaSeparatedListOutputParser()
print(parser.parse("mele, pere, banane")) # ['mele', 'pere', 'banane']OutputFixingParser
Quando il modello sbaglia formato, questo parser tenta di correggere chiamando un secondo LLM. Noi lo usiamo solo in contesti dove il costo extra è accettabile (es. batch notturni).
Chain: unire template, modello, parser
Una chain è un collegamento tra prompt, LLM e parser. LangChain ha LLMChain che fa tutto in una volta, ma per maggiore controllo usiamo LCEL (LangChain Expression Language).
LLMChain classica
from langchain.chains import LLMChain
from langchain.llms import OpenAI
llm = OpenAI(temperature=0)
chain = LLMChain(
prompt=template,
llm=llm,
output_parser=parser
)
risultato = chain.run(prodotto="caffè")
print(risultato) # già parsato come oggetto ProdottoChain con LCEL (moderno)
LCEL è più potente e componibile. Noi, di Meteora Web, abbiamo migrato tutti i progetti a LCEL:
from langchain.schema import StrOutputParser
from langchain.schema.runnable import RunnablePassthrough
chain = template | llm | parser
# equivalente: prompt -> LLM -> parser
risultato = chain.invoke({"piatto": "risotto"})Con LCEL puoi facimente aggiungere passaggi intermedi, logging, fallback. È il futuro.
Errori comuni (e come li risolviamo)
1. Il modello ignora le istruzioni di formato. Succede con modelli piccoli. Soluzione: aumentare la temperatura a 0.1, o usare few-shot con esempi nel prompt.
2. Output troppo lungo troncato. Alcuni output parser si aspettano un JSON completo. Se il modello si ferma, il parser fallisce. Noi usiamo RetryOutputParser o aggiungiamo un Stop token al prompt.
3. Variabili dimenticate nel template. PromptTemplate lancia un errore se manca una variabile. Controlla con prompt.input_variables.
Esempio completo: estrarre prodotti da un catalogo testuale
Mettiamo tutto insieme. Supponiamo un cliente (come Hibrido Abbigliamento) ha un catalogo in testo libero e vuole estrarlo in JSON.
from langchain.prompts import ChatPromptTemplate
from langchain.output_parsers import PydanticOutputParser
from pydantic import BaseModel, Field
from langchain.chat_models import ChatOpenAI
from langchain.schema.runnable import RunnablePassthrough
class Prodotto(BaseModel):
nome: str = Field(description="Nome del prodotto")
prezzo: float = Field(description="Prezzo in euro")
giacenza: int = Field(description="Quantità disponibile")
parser = PydanticOutputParser(pydantic_object=Prodotto)
prompt = ChatPromptTemplate.from_messages([
("system", "Sei un assistente che estrae dati strutturati da descrizioni di prodotto."),
("human", "Descrizione: {testo}\n{formato_istruzioni}")
])
# Inseriamo le istruzioni di formato come variabile
chain = (
{"testo": RunnablePassthrough(), "formato_istruzioni": lambda _: parser.get_format_instructions()}
| prompt
| ChatOpenAI(temperature=0, model="gpt-4")
| parser
)
testo_prodotto = "Maglietta in cotone biologico, 29.90€, solo 15 pezzi rimasti."
prodotto = chain.invoke(testo_prodotto)
print(prodotto.dict())Eseguendo, ottieni {"nome": "Maglietta in cotone biologico", "prezzo": 29.9, "giacenza": 15}. Dati pronti per il tuo ERP.
In sintesi — cosa fare adesso
- Identifica un punto della tua applicazione dove estrai dati da output LLM con parsing manuale (regex, split). Sostituiscilo con un output parser LangChain.
- Riscrivi i tuoi prompt usando
ChatPromptTemplatecon variabili, mai più stringhe concatenate a mano. - Usa LCEL per comporre catene anche semplici: è più manutenibile e permette di aggiungere logging o fallback in un secondo momento.
- Testa il parser con esempi reali: se il modello produce JSON valido ma con campi extra, Pydantic li ignora. Se manca un campo obbligatorio, cattura l'eccezione e riprova con un prompt più stretto.
- Non dimenticare la gestione errori: un fallimento del parser non deve mandare giù tutto il sistema. Logga e fallbacka.
Abbiamo visto aziende risparmiare ore di lavoro manuale di data entry grazie a queste tre componenti. E se vuoi approfondire come gli agenti AI orchestrano più catene, leggi la nostra guida su AI Agents. E per scrivere codice più veloce con l'AI, ecco la guida a Cursor AI.
Sponsored Protocol
