Prompts in LangChain | Generative AI using LangChain | Video 4 | CampusX

Video tutorial — Prompts in LangChain

Presenter: Nitish (CampusX) Scope: Video 4 in the series (focus on Prompts — how to design, send, and manage them in LangChain)

High-level scope

• Recap: previous videos covered LangChain intro, framework, components, and the Models component.
• This video focuses on Prompts — how to design, send, and manage them in LangChain.
• Goal: teach static vs dynamic prompts, PromptTemplate / ChatPromptTemplate, message types, using templates in UIs and chains, and building simple chatbots with context/history.

Key concepts and features

What is a prompt?

A “prompt” is the message(s) sent to an LLM. Model outputs are highly sensitive to prompt wording.

Temperature controls output randomness:

• Around 0 → deterministic/same output each run.
• Higher (e.g., ~1.5) → more creative / diverse outputs.

Static vs dynamic prompts

• Static prompt: user provides the entire prompt text.
  • Risks: inconsistent outputs, typos, users supplying undesired variations.
• Dynamic prompt: application generates a prompt from structured inputs (e.g., dropdowns) and templates.
  • Benefits: enforces consistent behavior, reduces user error.

PromptTemplate (LangChain)

• Purpose: create dynamic single-turn prompts with placeholders (examples: paper, style, length).
• Advantages over raw f-strings:
  • Built-in validation ensures required placeholders exist and prevents runtime errors.
  • Reusability: templates can be saved to JSON and loaded across pages/apps.
  • Integration: templates plug into LangChain chains cleanly.
• Example workflow: build a Streamlit UI that collects structured inputs → fill a PromptTemplate → invoke the model.

Chains

• Combine prompt generation and model invocation into a single chain.
• Benefit: call chain.invoke once instead of building the prompt and calling the model separately.

Building simple LLM apps (examples)

• Streamlit research assistant:
  • UI components: text input or selectboxes for paper, explanation style (math / code / simple), and length (short / medium / long).
  • Use a PromptTemplate, fill placeholders from the UI, invoke the model, and display the result.
• Console chatbot:
  • A simple loop that sends each user input as a prompt and prints the model response.

Chat history, message types, and multi-turn conversations

• Problem: single-turn prompts are stateless and lose context; multi-turn chat requires history.
• LangChain message types:
  • SystemMessage: instructional role, usually first (e.g., “You are a helpful assistant”).
  • HumanMessage: user messages.
  • AIMessage: model responses.
• Maintain chat history as a list of labeled messages (System / Human / AI) and send that list to the model for multi-turn context.

ChatPromptTemplate and MessagesPlaceholder

• ChatPromptTemplate: template for multi-message conversations (supports dynamic system/human messages).
• MessagesPlaceholder: special placeholder used inside ChatPromptTemplate to inject prior chat history (retrieved from a DB/file) at runtime. This allows the new conversation turn to include full past context.
• Notes/quirks:
  • Sometimes you may need to provide role-content tuples (e.g., (“system”, “…”)) for correct rendering.
  • LangChain APIs can vary between versions — follow the current LangChain docs.

Practical tips & debugging

• Prefer PromptTemplate / ChatPromptTemplate over ad-hoc f-strings for validation, reusability, and LangChain integration.
• Save templates to JSON for reuse across apps.
• Use labeled message objects so the LLM unambiguously sees who said what (system / human / AI).
• Use chains to simplify flows (template → model → result in one call).
• Be aware of LangChain version oddities — consult the docs when behavior differs.

Hands-on guides / code demonstrations (listed)

• Streamlit app:
  • Start with a research assistant using a text input and button.
  • Evolve to structured selects + PromptTemplate.
• PromptTemplate usage:
  • Create, validate, save as JSON, load with load_prompt, fill placeholders, invoke model.
• Chain usage:
  • Combine a PromptTemplate and model into a chain and call once.
• Console chatbot:
  • Basic loop, then add chat history list, then switch to tagged messages (SystemMessage / HumanMessage / AIMessage).
• ChatPromptTemplate + MessagesPlaceholder:
  • Load prior chat history from a file or DB, insert into the template, and send the whole message list to the model for context-aware replies.

Future / follow-up topics promised

• Deeper prompt engineering techniques:
  • Chain of Thought
  • Advanced prompting patterns
  • More templates

Main speaker / sources

• Presenter: Nitish (CampusX)
• Tools referenced:
  • LangChain (core, prompts, messages, PromptTemplate, ChatPromptTemplate, MessagesPlaceholder, chains)
  • OpenAI Chat models (ChatOpenAI)
  • Note: open-source models (e.g., Hugging Face) can be used as alternatives where applicable.