Introduction to LangChain – Building LLM Powerful Application with LangChain

What is LangChain ?

LangChain is a powerful natural language processing (NLP) library built on top of the PyTorch framework. It provides a comprehensive set of end-to-end tools for building NLP pipelines, including tokenization, part-of-speech tagging, named entity recognition, etc. In this guide, we show how to install and use LangChain, and build a complete app using LangChain, OpenAI, and Streamlit.

Why We Need LangChain and Its Attributes

NLP is an important area of ​​machine learning, enabling computers to understand and interpret human language. However, building effective NLP systems can be challenging, requiring a deep understanding of linguistics, data processing and machine learning. LangChain simplifies this process by providing a high-level API for common NLP tasks, making it easier to build robust NLP systems.

Some of the key attributes of LangChain include:

  • Easy-to-use API: LangChain offers a simple and intuitive API that makes it easy to perform common NLP tasks.
  • Modular design: LangChain is designed with modularity in mind, allowing developers to easily extend and customize its functionality.
  • PyTorch integration: LangChain is built on top of PyTorch, a popular machine learning framework, enabling users to leverage its powerful tools for training and deploying NLP models.
  • Pre-trained models: LangChain comes with pre-trained models for various NLP tasks, allowing users to quickly get started with their projects.

LangChain Installation Guide

To install LangChain, you’ll need to have PyTorch and Python installed on your machine. Follow these steps to install LangChain:

Install PyTorch by following the instructions on the official PyTorch website:

Install LangChain using pip:
pip install langchain

Verify that LangChain is installed correctly by running the following code:

import langchain

If LangChain is installed correctly, you should see a message indicating that the installation was successful.

Building a Complete App with LangChain + OpenAI + Streamlit, Step by Step

In this section, we’ll build a complete app that uses LangChain, OpenAI’s GPT-3 language model, and Streamlit, a web framework for building data apps. We’ll walk through each step of the process, from installing the necessary libraries to deploying the app.

Step 1: Install Required Libraries

Before we begin, we’ll need to install several libraries:

  • langchain: This is the core library we’ll be using for NLP tasks.
  • openai: This library provides access to the GPT-3 language model.
  • streamlit: This is the web framework we’ll use to build the app.

You can install these libraries using pip:

pip install langchain openai streamlit

Step 2: Create a Streamlit App

Now that we’ve installed the necessary libraries, we can begin building our app. First, let’s create a new file called and import the required libraries:

import streamlit as st
import openai
import langchain

Next, we’ll need to authenticate with OpenAI’s API. Follow the instructions on the OpenAI website to obtain an API key, and then use the following code to authenticate:

openai.api_key = "YOUR_API_KEY_HERE"

Replace YOUR_API_KEY_HERE with your actual API key.

Now we can start building the app. Let’s begin by creating a streamlit app to showcase the power of LangChain.

Let’s start –

In this section, we will build a complete app that uses LangChain to generate text with OpenAI’s GPT-3 and display the results using Streamlit. This app will demonstrate the power and flexibility of LangChain and its ability to integrate with other powerful tools.

We will start by creating a new Python file called and importing the necessary packages:

import streamlit as st
import openai
from langchain import LangChain

Next, we need to authenticate with OpenAI. We will use the API key we obtained earlier:

openai.api_key = "<your_api_key>"

Now, let’s create a function called generate_text that takes in a prompt and returns the generated text using LangChain and OpenAI:

def generate_text(prompt):
    lc = LangChain()
    response = openai.Completion.create(
        n = 1,
    return response.choices[0].text.strip()

This function creates a new LangChain instance, adds the generate_text token, adds the prompt text, and compiles the LangChain code into a prompt that can be passed to OpenAI’s API. We use the davinci engine to generate the text and set some parameters such as the temperature and maximum number of tokens to use.

Now, let’s create the Streamlit app by defining the UI and logic:

def app():
    st.title("LangChain + OpenAI + Streamlit Demo")
    prompt = st.text_input("Enter Prompt")
    if st.button("Generate Text"):
        with st.spinner("Generating Text..."):
            generated_text = generate_text(prompt)

Here, we define a function called app that creates the Streamlit UI. The UI consists of a title and a text input field where the user can enter the prompt text. When the user clicks the “Generate Text” button, the generate_text function is called and the generated text is displayed below the button.

Finally, we run the app using Streamlit’s run_app function:

if __name__ == "__main__":

That’s it! We have now created a fully functional app that uses LangChain to generate text with OpenAI and display the results using Streamlit.

LangChain Sentiment Analysis on Customer Reviews


In this project, we will use LangChain for sentiment analysis on customer reviews. We will build a pipeline that takes in customer reviews, preprocesses the text data, and applies a sentiment analysis model to classify the reviews as either positive, negative or neutral.


We will use a dataset of customer reviews from The dataset contains reviews for various products, such as books, electronics, and movies. Each review is labeled as either positive, negative or neutral.


Before applying the sentiment analysis model, we need to preprocess the text data. The preprocessing steps include:

  • Removing special characters and punctuation marks
  • Converting all text to lowercase
  • Removing stop words (such as “the”, “and”, “a”, etc.)
  • Tokenizing the text into words

We will use LangChain for the text preprocessing steps. Here is the code for the preprocessing pipeline:

from langchain import LangChain

# Create LangChain instance
lc = LangChain()

# Define preprocessing steps
lc.add_step('lowercase', lambda x: x.lower())
lc.add_step('remove_special_chars', lambda x: re.sub('[^A-Za-z0-9]+', ' ', x))
lc.add_step('remove_punctuation', lambda x: x.translate(str.maketrans('', '', string.punctuation)))
lc.add_step('tokenize', lambda x: word_tokenize(x))
lc.add_step('remove_stopwords', lambda x: [word for word in x if word not in stopwords.words('english')])

# Preprocess text
text = 'This is a sample sentence.'
processed_text =


For the sentiment analysis model, we will use a pre-trained model from the Hugging Face Transformers library. The model is based on a deep neural network architecture and has been trained on a large corpus of text data.

Here is the code to load the model:

from transformers import pipeline

# Load sentiment analysis model
model = pipeline('sentiment-analysis')


Now that we have our preprocessing pipeline and sentiment analysis model, we can apply them to the customer reviews. Here is the code for the inference pipeline:

# Define inference pipeline
def predict_sentiment(review):
    # Preprocess text
    processed_text =
    # Convert processed text back to string
    processed_text = ' '.join(processed_text)
    # Apply sentiment analysis model
    result = model(processed_text)[0]
    # Extract sentiment label
    sentiment_label = result['label']
    # Map sentiment label to numeric score
    if sentiment_label == 'POSITIVE':
        sentiment_score = 1
    elif sentiment_label == 'NEGATIVE':
        sentiment_score = -1
        sentiment_score = 0
    return sentiment_score

# Test inference pipeline
review = 'I really enjoyed this book!'
sentiment_score = predict_sentiment(review)

In above project, we used LangChain for text preprocessing and a pre-trained sentiment analysis model from the Hugging Face Transformers library to classify customer reviews as either positive, negative or neutral. LangChain provides a convenient way to define and apply text preprocessing pipelines, while the Hugging Face Transformers library provides a wide range of pre-trained models for natural language processing tasks.


Sentiment Analysis App using LangChain

In this project, we will build a Sentiment Analysis app using LangChain, which will analyze the sentiment of a given text input and provide a positive, negative, or neutral sentiment output.

  1. Installing LangChain and other Dependencies

Before we start building the app, we need to make sure we have installed LangChain and other dependencies. You can follow the installation guide provided in the previous project section.

In addition to LangChain, we will also be using the TextBlob library for performing sentiment analysis. You can install it using the following command:
pip install textblob

  1. Building the App

We will be using the Streamlit library to build a simple and intuitive user interface for our Sentiment Analysis app.

Let’s start by creating a new Python file named and importing the required libraries.

import streamlit as st
from textblob import TextBlob
from langchain.client import LangChainClient

Next, we need to create a LangChainClient object and authenticate it using our API key.

api_key = 'YOUR_API_KEY'
client = LangChainClient(api_key)

Now, let’s define the UI elements for our app using Streamlit.

st.title("Sentiment Analysis App using LangChain")

text_input = st.text_area("Enter text to analyze sentiment:")
analyze_button = st.button("Analyze Sentiment")
result_text = st.empty()

We have created a title for our app and a text area for the user to input the text to be analyzed. We also have a button for the user to trigger the sentiment analysis and an empty placeholder where we will display the sentiment result.

Next, we need to define the function that will perform the sentiment analysis using LangChain and TextBlob.

def perform_sentiment_analysis(text):
    # Translate text to English using LangChain
    response = client.translate_text(text, target_language='en')
    english_text = response['translations'][0]['text']

    # Perform sentiment analysis using TextBlob
    blob = TextBlob(english_text)
    sentiment_polarity = blob.sentiment.polarity
    sentiment_subjectivity = blob.sentiment.subjectivity

    # Return sentiment result
    if sentiment_polarity > 0:
        return "Positive"
    elif sentiment_polarity < 0:
        return "Negative"
        return "Neutral"

The perform_sentiment_analysis function takes in the text input, translates it to English using LangChain, and performs sentiment analysis using TextBlob. It then returns the sentiment result as a string.

Finally, we need to define the event handler for the “Analyze Sentiment” button.

if analyze_button:
    if len(text_input.strip()) > 0:
        result = perform_sentiment_analysis(text_input)
        result_text.success(f"Sentiment: {result}")
        result_text.warning("Please enter some text to analyze sentiment.")

If the user clicks on the “Analyze Sentiment” button and there is some text input, we call the perform_sentiment_analysis function and display the sentiment result using the result_text.success method. If there is no text input, we will display a warning message using the result_text.warning method.

  1. Running the App

To run the app, simply navigate to the directory where we have saved the file and run the following command in terminal:
streamlit run

We should see the app open in your browser. Enter some text in the input field.

After entering some text in the input field, the LangChain app will tokenize the text and convert it into the target language selected by the user. This process involves breaking down the text into individual words, identifying the part of speech for each word, and generating the equivalent words in the target language based on the identified parts of speech.

To demonstrate this process, let’s consider an example where we want to translate a sentence from English to French. We can use the LangChain app to accomplish this task.

First, we need to enter the sentence in the input field. Let’s consider the sentence: “The quick brown fox jumps over the lazy dog.”

Next, we need to select the source language, which is English in this case, and the target language, which is French.

Once we have selected the languages, we can click on the “Translate” button, which will trigger the LangChain app to tokenize the sentence and convert it into French.

The resulting output will be displayed in the output field, which should contain the translated sentence: “Le renard brun rapide saute par-dessus le chien paresseux.”

Last Updated on August 12, 2023 by admin


Leave a Reply

Your email address will not be published. Required fields are marked *

Recommended Blogs