LangChain makes it easy to create powerful AI-driven workflows by chaining together different language model tasks. In this guide, we’ll walk through setting up a simple yet flexible pipeline that answers questions, summarizes responses, and even analyzes sentiment—just like a human expert would.

Getting Started: A Basic Question-Answering Pipeline

Let’s begin with a straightforward setup where a user asks a question, and the language model provides a detailed answer.

Step 1: Setting Up the Language Model

First, we’ll use OpenAI’s text-davinci-003 model, tweaking its creativity with the temperature parameter (higher values make responses more varied).

python

Copy

Download

from langchain.llms import OpenAI

from langchain.prompts import PromptTemplate

from langchain.chains import LLMChain

 

# Initialize the model with controlled randomness

llm = OpenAI(model=”text-davinci-003″, temperature=0.7)

 

# Define a prompt template to structure the question

prompt_template = PromptTemplate(

input_variables=[“question”],

template=”You’re a knowledgeable assistant. Answer this in detail: {question}”

)

 

# Combine the model and prompt into a chain

qa_chain = LLMChain(llm=llm, prompt=prompt_template)

 

# Ask a question and get the response

response = qa_chain.run({“question”: “How does LangChain simplify AI workflows?”})

print(response)

How It Works

1. User Input: The question (“How does LangChain simplify AI workflows?”) is passed in.
2. Prompt Assembly: The template formats it into:
   “You’re a knowledgeable assistant. Answer this in detail: How does LangChain simplify AI workflows?”
3. Model Processing: The LLM generates a detailed response.
4. Output: The answer is printed.

For example, the model might return:
“LangChain provides modular components that let developers chain together language model calls, data processing, and external API integrations, making it easier to build complex AI applications without starting from scratch.”

Enhancing the Pipeline: Adding Summarization

Now, let’s refine our workflow by condensing the long-form answer into a quick summary.

Step 2: Chaining a Summary Step

We’ll add a second prompt that takes the initial response and shortens it.

python

Copy

Download

from langchain.chains import SequentialChain

 

# First prompt: Detailed answer

answer_prompt = PromptTemplate(

input_variables=[“question”],

template=”Explain this in depth: {question}”

)

# Second prompt: Summary

summary_prompt = PromptTemplate(

input_variables=[“response”],

template=”Summarize this in one sentence: {response}”

)

# Define both chains

answer_chain = LLMChain(llm=llm, prompt=answer_prompt, output_key=”response”)

summary_chain = LLMChain(llm=llm, prompt=summary_prompt, output_key=”summary”)

# Link them together

pipeline = SequentialChain(

chains=[answer_chain, summary_chain],

input_variables=[“question”],

output_variables=[“response”, “summary”]

)

# Run the full pipeline

result = pipeline({“question”: “What are the key features of LangChain?”})

print(“Detailed Answer:”, result[“response”])

print(“\nSummary:”, result[“summary”])

Expected Output

• Detailed Answer: “LangChain offers tools for connecting language models to external data, managing memory for conversations, and creating multi-step workflows. It supports prompt templating, document retrieval, and agent-based decision-making, making it versatile for developers.”
• Summary: “LangChain provides tools for integrating AI models with data, memory, and multi-step workflows.”

Taking It Further: Sentiment Analysis (Optional Challenge)

For an even smarter pipeline, let’s add a third step that detects whether the summary is positive, neutral, or negative.

Step 3: Adding Sentiment Detection

python

Copy

Download

# Sentiment analysis prompt

sentiment_prompt = PromptTemplate(

input_variables=[“summary”],

template=”Is the tone of this text positive, neutral, or negative? Text: {summary}”

)

# Create the sentiment chain

sentiment_chain = LLMChain(llm=llm, prompt=sentiment_prompt, output_key=”sentiment”)

# Update the pipeline

full_pipeline = SequentialChain(

chains=[answer_chain, summary_chain, sentiment_chain],

input_variables=[“question”],

output_variables=[“response”, “summary”, “sentiment”]

)

# Run the complete workflow

final_result = full_pipeline({“question”: “Why is LangChain useful for developers?”})

print(“Answer:”, final_result[“response”])

print(“\nSummary:”, final_result[“summary”])

print(“\nSentiment:”, final_result[“sentiment”])

Sample Output

• Answer: “LangChain helps developers by simplifying complex AI tasks like chaining model calls, handling memory in conversations, and integrating with databases or APIs, reducing the need for custom coding.”
• Summary: “LangChain streamlines AI development by automating workflows and integrations.”
• Sentiment: “positive”

Why This Matters

By breaking down tasks into modular steps—answering, summarizing, and analyzing sentiment—we can build flexible, powerful AI workflows. This approach mirrors how humans process information: gather details, condense them, and interpret tone.

Key Takeaways

• Modular Design:Each step (answering, summarizing, sentiment) is reusable.
• Scalability:Easily add new steps (translation, keyword extraction, etc.).
• Readability:Clear, structured code makes maintenance simpler.

With these fundamentals, you can start crafting advanced AI applications that feel intuitive and human-like. Next, try adding translation, fact-checking, or even integrating external APIs for richer functionality!