Chains in LangChain | Generative AI using LangChain | Video 7 | CampusX

Tech concepts & what the video teaches

• LangChain “Chains” as pipelines: Instead of manually calling a prompt → LLM → output parsing step-by-step, chains connect those steps into an automatic pipeline where the output of one step becomes the input to the next.
• Why chains are needed: They reduce manual effort and simplify building large/complex LLM applications by composing multiple smaller steps.

• Chain Expression Language (LCEL) syntax: Chains are built declaratively by connecting components with a pipe operator (|), forming a pipeline like: prompt template → model → output parser.

• Invocation model: After building a chain, you trigger it once (via an invoke/evoke-style invocation), providing input only at the first step.

Chains covered (3 main types)

1) Sequential Chains (including multi-step / multi-LLM)

• Simple 3-step chain example:

  1. Prompt template generates instructions (e.g., “Generate five interesting facts about {topic}”).
  2. LLM call (e.g., ChatOpenAI).
  3. String output parser converts the model response into a plain string.

• Visualization: Uses get_graph().print_ascii() to display the chain structure (prompt input → model → parser).

• Longer sequential chain example (LLM called twice):

  • Step 1: Ask for a detailed report on a topic.
  • Step 2: Feed the report back into the same LLM to produce a summary of 5 key points.
  • This demonstrates how intermediate outputs can flow from one step into the next.

2) Parallel Chains

• Use case: Given a large document/text:

  • Branch A generates notes
  • Branch B generates a quiz
  • Then a final step merges both outputs into a single result.

• Parallel execution primitive: RunnableParallel Runs multiple sub-chains simultaneously (e.g., notes chain with one model, quiz chain with another).

• Model routing in the example:

  • One branch uses ChatOpenAI (notes)
  • Another uses ChatAnthropic (quiz)

• Merge step: A final sequential chain takes both outputs (notes + quiz) and combines them.

• Visualization: Also uses get_graph().print_ascii() to show the parallel structure.

• Practical note: The code may break if a model name is incorrect; they correct the second model naming.

3) Conditional Chains (if/else behavior)

• Use case: Sentiment-based product feedback handling:

  • Classify feedback as positive or negative
  • If positive → generate a positive response (e.g., “thank you for your kind words”)
  • If negative → generate a negative-appropriate response (in a fuller agent setup, could also trigger actions like support emails/forms)

• Key limitation highlighted: Plain LLM outputs may be inconsistent (e.g., returning unexpected text instead of exactly positive/negative), which can break branching logic.

• Structured output to fix reliability:

  • Uses Pydantic output parsing (PydanticOutputParser + BaseModel)
  • Defines a schema with a literal field:
    • sentiment: Literal["positive", "negative"]
  • Ensures the classifier output is always one of those exact tokens.

• Branching primitive: RunnableBranch Implements if/else-if/else logic using conditions based on the structured classification result. Only the matching branch runs (not parallel; just one path executes).

Other implementation details emphasized

• StringOutputParser is used to convert LLM output into plain strings.
• LCEL + chaining composition is the core mechanism used across sequential, parallel, and conditional examples.
• Visualization support (get_graph().print_ascii()) is repeatedly used to understand pipeline flow.

Main speakers / sources

• Speaker: Nitesh (host/teacher of the “CampusX” LangChain playlist)
• Primary source/library: LangChain (models, prompt templates, parsers, RunnableParallel, RunnableBranch, and LCEL pipe syntax)