Summary of "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)

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.

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

Temperature controls output randomness:

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.

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.

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.

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.

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: 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.

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.

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.

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

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.