What Is LangChain and How to Use It

In the dynamic world of artificial intelligence, a plethora of LLMs are available, each having its specialties and capabilities. What if you could harness the strengths of not just one but multiple LLMs within your business applications?

With LangChain, it’s entirely achievable. It is a robust solution that enhances your application with advanced capabilities through stateful interactions and support for integrations with APIs and external systems.

Let’s see how LangChain makes it easier to develop, optimize, and deploy LLM-powered applications step by step.

What Is LangChain? 

LangChain is a framework that helps you create applications using Large Language Models like ChatGPT. It makes the whole process of building and running these applications more efficient. by allowing integration with tools and services for each step: 

• Development: LangChain provides ready-made components and features for Application building. For example, it offers a tool called LangGraph, which allows you to create applications that help you track information over time. 
• Production: Once your application is built, you can use another tool, LangSmith, to check its performance. This tool lets you monitor and test your application so it performs better over time.
• Deployment: After your application is ready, you can use LangGraph Cloud to make it available as an online service, such as an API or a chatbot.

How to Work with LangChain? 

LangChain enables you to streamline the development of LLM applications by providing high-level components called abstractions. These components can be chained together to create applications, reducing the need for custom logic to implement individual NLP tasks such as text generation or question answering. 

LangChain Modules or Components 

LangChain offers an extendable set of interfaces and integrations. Using these components, you can create applications. Here are some of the main LangChain components: 

Model 

The model component represents the core machine learning models you use in your applications. LangChain provides interfaces to integrate and manage a variety of models, including chat models and LLMs.  

Prompt Templates 

Prompts are instructions given to a Large Language Model, and the prompt template class in the LangChain formalizes the composition of prompts. Using prompt templates, you can fine-tune and optimize these models within LangChain. 

For example, a prompt template can contain instructions like ‘do not use technical terms in your response.’ Or it could be a set of instructions that guide the model’s responses. 

Chains 

Chains are the core of LangChain workflows. They enable you to combine multiple elements and sequences to create complex workflow and processes. Using chains, you can link various tools, models, and actions to perform intricate tasks. 

For example, let’s say there is an application that needs to perform the following functions: 

• Retrieve the data from a website. 
• Summarize the text it gets back.
• Use that summary to answer a user-submitted question.

It is a sequential chain where the output of one of the functions works as the input for another function. Each function in the chain can use different parameters, prompts, and even different models.

Retrieval 

Sometimes, your LLM application requires user-specific data that is not part of the model’s training set. LangChain provides building blocks for RAG applications, ranging from simple to complex. Through Retrieval Augmented Generation, external data is retrieved and passed into LLM when performing the generation step.  

The retrieval component in LangChain consists of several modules, including: 

• Document Loaders: Document loaders load documents from a variety of sources. LangChain offers over 100 different document loaders. Using these, you can load different types of documents, such as HTML, PDF, and code, from sources like S3 buckets into your workflow.
• Text Splitting: LangChain provides multiple algorithms for splitting large documents into smaller, manageable chunks. The process of chunking is essential for efficient retrieval of data.
• Text Embedding Models: An essential aspect of RAG is creating embedding for documents. These embeddings capture the semantic meaning of the text by converting it into a numeric form, enabling quick and efficient searches. LangChain offers integration with over 25 different embedding providers, providing a standard interface to switch between models easily. 
• Vector Stores: These are vector databases that support and enable the storage of embeddings. LangChain integrates with over 50 different vector stores, open-source and cloud-hosted. 
• Retrievers: Once data is stored in the database, it still needs to be retrieved. LangChain supports various retrieval algorithms, including a parent document retriever, a self-query retriever, and an ensemble retriever. 
• Indexing: The LangChain indexing API enables the syncing of data between a source and a vector store. Indexing helps avoid data duplication and save time, improving search results. 

Agents 

Agents in LangChain are systems that use LLMs as reasoning engines to decide which actions to take and the inputs required to generate the desired output. These agents can interact with various tools to perform tasks. By leveraging an executor, the agents can manage the execution of the task, parse the result, and determine subsequent steps. 

Output Parsers 

Output Parsers in LangChain are responsible for formatting the output generated by the LLMs. This is useful when you are using LLM to create any form of structured data. LangChain offers different output parsers, and many of them support stream processing. 

Memory 

LangChain offers utilities to add memory to your system. These memories are designed to help your application retain context, remember past interactions, and use this information to improve future responses. By incorporating memory components, you can create more context-aware applications.

How to Get Started with LangChain 

Now that you have explored the components of LangChain and how they help create applications, let’s dive into the practical steps to get started.

Setting Up the Environment

The first step is setting up your development environment. Here’s how you can prepare everything for a smooth start within a Python environment. If you are not familiar with Python, you can opt for JavaScript. 

Install LangChain

You need to install LangChain. It is straightforward and similar to installing other libraries using the pip command: 

pip install langchain

Install OpenAI

As there are various LLMs that you can use with LangChain, let’s use OpenAI in this example. You can install OpenAI in a Python environment using the following command:

pip install openai

Set up Secure API Key Handling 

You can generate your own API key by signing up on the Open AI platform. To securely manage your OpenAI API Key, use the getpass and os modules to prompt for and set the API key as an environment variable. 

import getpass
import os

if not os.environ.get("OPENAI_API_KEY"):
    os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter API key for OpenAI: ")

from langchain_openai import ChatOpenAI

model = ChatOpenAI(model="gpt-4o-mini")

This setup ensures your environment is configured securely and ready to use LangChain with OpenAI.

Using Language Model 

ChatModels are instances of LangChain Runnables, which means they expose a standard interface for interacting with them. To call the model, you can pass a list of messages using the .invoke method. 

from langchain_core.messages import HumanMessage, SystemMessage
messages = [
    SystemMessage(content="Translate the following from English into Italian"),
    HumanMessage(content="hi!"),
]
response = model.invoke(messages)
print(response.content)

By running the above code snippet, you will see the output printed in your console or terminal, confirming that the model processes the input message. The output translates the English word ‘hi!’ into Italian as per the instruction provided in the SystemMessage. 

Create Prompt Templates 

Prompt templates are designed to extract raw user input and apply transformation logic to it. The transformation step ensures that the unstructured input is modified into a format compatible with the language model. You can create a prompt template for the above example: 

Define the Prompt Template Using the Below Command

Set up a structure for translating text using placeholders for language and text. 

from langchain_core.prompts import ChatPromptTemplate
system_template = "Translate the following from English into {language}"
prompt_template = ChatPromptTemplate.from_messages(
    [("system", system_template), ("user", "{text}")]
)

Invoke the Template 

Fill the placeholder with actual values (“Italian” and “hi!”) and create a formatted prompt.

prompt = prompt_template.invoke({"language": "Italian", "text": "hi!"})
print(prompt.to_messages())

Use the Template With the Model 

Send the formatted prompt to the model and print the translated output. 

response = model.invoke(prompt)
print(response.content)

What Kind of Apps Can You Build Using LangChain? 

You can build different types of applications with LangChain, from simple text generation to complex solutions that use LLMs for reasoning engines. Here are some examples: 

Chatbots 

Chatbots are software applications designed to simulate human conversations. LangChain allows you to integrate LLMs that can understand and generate human-like responses, making your chatbot conversations feel natural and engaging. Using LangChain, you can build chatbots for tasks like customer support or personal assistance.

Content Generation Apps

Content generation apps are tools that provide content in the form of text or images for the given input query. LangChain allows you to integrate LLMs to generate high-quality text content based on given prompts. These models can create articles, blog posts, and social media updates. You can also leverage tools such as Dall-E to create images. 

Data Analysis and Insights 

Data analysis applications process and analyze large datasets to provide insights and support decision-making. With LangChain, you can build data analysis tools that utilize LLMs to interpret and summarize data. These types of applications are particularly useful in fields like finance, healthcare, and market research. 

What Is the Benefit of Using Langchain?

• Flexibility: LangChain offers a variety of tools, including chains, prompts, and agents. It also supports integration with external sources and provides cross-language and platform compatibility. All these features make LangChain suitable for dynamic and evolving use cases.
• Scalability: Whether you are handling small projects or enterprise applications, LangChain supports efficient scaling. It can manage increasing workloads by distributing tasks across multiple LLMs and optimizing resource usage. 
• Data Silos: LangChain helps bridge data silos by allowing you to integrate disparate data sources through connectors and APIs in a unified framework. This enables you to query and interact with structured and unstructured data across platforms, breaking down barriers between isolated information. 
• Accelerate Development: LangChain abstracts the complexities of integrating and managing LLMs, reducing the development time. This allows your team to focus on delivering value-added features rather than grappling with backend challenges. 

Conclusion

LangChain stands out as a powerful framework for leveraging the full potential of LLMs in modern applications. Its flexibility, scalability, and modularity enable you to easily integrate LLMs into your projects, whether it’s building Chatbots or content generation tools. Its varied components simplify the process of creating intelligent and context-aware applications, making it a valuable tool to stay ahead of the AI-driven landscape.