Working with Language Models in LangChain

A straightforward API for all the language models

Introduction to Language Models in LangChain

In today’s digital age, language models have established their significance in various applications, from chatbots to content generation, and enhancing user experiences across platforms. Imagine harnessing the power of multiple state-of-the-art language models through one unified interface. This is precisely what LangChain offers — a single API to bridge the gap between different language models, ensuring seamless integration and interaction.

The beauty of LangChain is its inherent adaptability. Whether you’re keen on using the capabilities of OpenAI, Cohere, or HuggingFace, LangChain ensures that the transition between these models is as smooth as possible. Its Model I/O module provides a structured approach to interact with these models, ensuring that developers can focus on building applications rather than grappling with API-specific nuances.

This guide will walk you through the essentials of working with LangChain, detailing the components that make it tick, and demonstrating its versatility. Whether aiming to generate text or engage in intricate dialogues with the model, LangChain has got you covered.

Dive in, and let’s explore the world of language models through the lens of LangChain.

%%capture
!pip install langchain openai cohere transformers

import getpass
import os

os.environ["OPENAI_API_KEY"] = getpass.getpass("Open AI API Key:")

os.environ["COHERE_API_KEY"] = getpass.getpass("Cohere API Key:")

os.environ["HUGGINGFACEHUB_API_TOKEN"] = getpass.getpass("HuggingFace API Key:")

If you remove language models from the picture, 🦜🔗 LangChain is pretty much useless.

That’s why the most essential module of 🦜🔗 LangChain is Model I/O, which gives you the building blocks for interacting with a language model.

There are three components to this module:

1) Prompts, which provide templates that allow you to parametrize and reuse prompts.

2) Language models, which allow you to interface with:

• LLMs, which take a string as input and return a string as output
• Chat models, which take a list of chat messages as input and return

3) Output Parsers allow you to extract and structure the text output from a language model in the way you want. These are useful for tasks like QA, where you must parse an answer.

The typical workflow is as follows:

• Choose either an LLM or a Chat model; this depends on your use case
• Construct a prompt that you customize as the inputs
• Send the input to the LLM or Chat model
• Parse outputs with output parsers, if needed

Want to build real-world applications with LLMs? Try this free LLMOps course from industry-expert Elvis Saravia of DAIR.AI!

🖱️ Let’s double-click on the language models component.

In general, all Chat models are LLMs. But, not all LLMs are Chat models.

But both implement the same Base Language Model interface, making it easy to swap between them.

🗣️ LLMs:

• Take a string as input and return a string as output
• Implemented for models optimized for text completion
• Expose a predict method that takes a string prompt and returns a string completion

💬 Chat models:

• Take a list of ChatMessages as input and return a ChatMessage as output
• Implemented for models that are tuned for dialogue
• Expose a predict_messages method that takes a list of ChatMessages and returns a single ChatMessage
• ChatMessages contain a content field with the message text and a role field indicating the speaker

🔑 The key differences:

• Input/output types: strings vs. ChatMessages
• Methods: predict vs. predict_messages
• Optimization: text completion vs. dialog

Working LLMs

The LLM class is designed to be a standard interface to an LLM provider. This class abstracts away provider-specific APIs and exposes common methods like predict and generate.

• predict is optimized for text completion. It allows you to format and pass a prompt template to the language model. The output is just plain text.

• generate takes a list of prompts and returns detailed LLMResult objects with completions and metadata.

Let’s instantiate LLMs from Cohere, OpenAI, and HuggingFace and look at the difference between the generate and predict methods.

Predict method

Notice that it’s the same API for each model, which is nice.

from langchain.llms import OpenAI, Cohere, HuggingFacePipeline, HuggingFaceHub

openai_llm = OpenAI()

cohere_llm = Cohere()

huggingface_llm = HuggingFaceHub(repo_id="tiiuae/falcon-7b", model_kwargs={"max_length": 1000})

prompt = "How do I become an AI Engineer?"

openai_llm.predict(prompt)

And the model will give the following response:

1. Earn a Bachelor’s Degree: To become an AI engineer, you will need at least a bachelor’s degree in computer science, mathematics, or a related field.

2. Gain Experience: It is important to gain experience in the field of AI engineering. This can be done through internships, research projects, and taking courses in AI-related topics.

3. Get Certified: AI engineers can become certified in various areas of AI technology, such as natural language processing, robotics, machine learning, and more.

4. Develop Your Skills: AI engineers must continually develop their skills to stay up-to-date with the latest technologies and trends. This can be done through attending conferences, reading books, and taking courses.

5. Stay Informed: To stay ahead of the game, AI engineers must stay informed of the latest trends and technologies in the field. This can be done through reading industry blogs, attending conferences, and networking with others in the field.

Getting output from Cohere

cohere_llm.predict(prompt)

Which produces the following output:

There is no one answer to this question, as the path to becoming an AI Engineer will vary depending on your background and experience. However, some tips on how to become an AI Engineer include:

1. Getting a degree in computer science or a related field.
2. Learning the basics of machine learning and artificial intelligence.
3. Working on projects related to machine learning and artificial intelligence.
4. Networking with other AI Engineers and professionals.
5. Stay up to date on the latest developments in the field.

If you have any questions or need any help along the way, feel free to ask me!

Getting output from a HuggingFace model

We left the generation parameters alone, but you can change those.

huggingface_llm.predict(prompt)

The AI Engineer is a new role that is emerging in the tech industry. It is a combination

Generate

And as you can see below, the generate method gives more details:

LLMResult(generations=[[Generation(text=" To become an AI engineer, you will need to complete a bachelor's or master's degree in a relevant field such as computer science, machine learning, or data science. You will also need to have strong programming skills and experience with machine learning algorithms.\n\nAfter completing your education, you will need to find a job in the AI field. This can be done by applying to companies that are hiring AI engineers or by working on your own projects.\n\nTo be successful as an AI engineer, you will need to be able to work well in a team, have strong communication skills, and be able to think creatively. You will also need to be able to keep up with the latest developments in the field and be willing to learn new skills.", generation_info=None)]], llm_output=None, run=[RunInfo(run_id=UUID('79920107-3a34-4d61-b95e-280420ad3899'))])

Working with Chat models

We’ll stick to the OpenAI chat models for this section.

The chat model interface is based around messages rather than raw text.

The types of messages currently supported in LangChain are AIMessage, HumanMessage, SystemMessage.

from langchain.chat_models import ChatOpenAI

from langchain.schema import (
    AIMessage,
    HumanMessage,
    SystemMessage
)

llm = OpenAI(model_name="gpt-3.5-turbo")
chat = ChatOpenAI()

messages = [
    SystemMessage(content="You are a tough love career coach who gets to the point and pushes your mentees to be their best."),
    HumanMessage(content="How do I become an AI engineer?")
]

chat(messages)

There you have it.

It’s the basics, and we’ll build on it from here.

Conclusion: Navigating the Future with LangChain

As we’ve journeyed through the intricacies of LangChain, it’s evident that the world of language models is not just about individual capabilities but also about integration and accessibility. LangChain stands out as a beacon of innovation in this context, offering a unified interface to tap into the vast potential of various leading language models. Its adaptability, structured approach, and ease of use make it an indispensable tool for developers and businesses.

The future of digital communication and AI-driven applications is deeply intertwined with language models. As these models evolve, so will our need for platforms like LangChain that simplify complexities and empower us to create transformative solutions. Whether you’re an AI enthusiast, a developer, or a business leader, embracing tools like LangChain will undeniably position you at the forefront of this AI revolution.

Here’s to harnessing the combined might of the world’s best language models and to the countless innovations that await us. With LangChain by our side, the horizon looks promising and limitless.