Dynamic Prompting with LangChain

Writing one prompt by hand is easy. Building an app that fills prompts with live data, calls a model, cleans the reply and passes it to the next step is harder. LangChain gives you small building blocks that snap together with a simple | pipe, like Lego.

01Prompt templates

A prompt template is a prompt with blanks to fill at run time. It keeps your prompt text in one place and makes it reusable.

# pip install langchain-core langchain-openai
from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful banking tutor."),
    ("user", "Explain {topic} in one line."),
])
print(prompt.invoke({"topic": "UPI"}).to_messages())

02Output parsers

A chat model returns a message object. An output parser turns it into what your code needs:

• StrOutputParser: just the text.
• JsonOutputParser: a Python dict.
• PydanticOutputParser or llm.with_structured_output(Model): a validated object (Session 28).

03LCEL: the pipe operator

The LangChain Expression Language joins steps with |. The output of each step becomes the input of the next:

from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
chain = prompt | llm | StrOutputParser()

print(chain.invoke({"topic": "UPI"}))

04Runnables: one interface for everything

Prompts, models, parsers and whole chains are all Runnables, so they share the same methods:

answers = chain.batch([{"topic": "UPI"}, {"topic": "NEFT"}, {"topic": "IMPS"}])

for piece in chain.stream({"topic": "RTGS"}):
    print(piece, end="", flush=True)

You can also turn any Python function into a Runnable with RunnableLambda, and pass input through unchanged with RunnablePassthrough.

05Sequential and parallel chains

Sequential: one step feeds the next

Example: summarise a customer complaint in English, then translate the summary into Hindi for the branch team.

summarise = ChatPromptTemplate.from_template("Summarise this complaint in one line:\n{complaint}") | llm | StrOutputParser()
translate = ChatPromptTemplate.from_template("Translate to Hindi:\n{summary}") | llm | StrOutputParser()

pipeline = {"summary": summarise} | translate     # the dict maps the first output into {summary}
print(pipeline.invoke({"complaint": "I was charged twice for my electricity bill payment on 3 Oct…"}))

Parallel: several jobs on the same input

RunnableParallel runs branches at the same time and returns a dict, which saves waiting time.

from langchain_core.runnables import RunnableParallel, RunnablePassthrough

sentiment = ChatPromptTemplate.from_template("Sentiment (positive/negative/neutral) of: {text}") | llm | StrOutputParser()
keywords  = ChatPromptTemplate.from_template("3 keywords from: {text}") | llm | StrOutputParser()

analyse = RunnableParallel(sentiment=sentiment, keywords=keywords, original=RunnablePassthrough())
print(analyse.invoke({"text": "Got my refund after a delay, thanks!"}))

Output above from running with a fake model on langchain-core; a real model’s wording will differ.

06Summary

• Prompt templates hold reusable prompts with blanks.
• Output parsers turn model messages into text, dicts or validated objects.
• LCEL joins steps with |: prompt | llm | parser.
• Every piece is a Runnable with invoke, batch and stream.
• Chain steps sequentially or run them in parallel with RunnableParallel.

07Quick quiz

08References

• LangChain Expression Language (LCEL)
• Runnable interface