Add Memory to AI21 Labs Models with LangChain: A Step-by-Step Tutorial

Introduction

In recent years, AI models have advanced dramatically, allowing developers to create chatbots and conversational agents with relative ease. AI21 Labs has introduced several models that empower users to harness the potential of artificial intelligence. However, one challenge many developers face is the manual tracking of interactions with these models. This is where LangChain comes into play, streamlining the process of managing conversation history. In this guide, we'll walk through how to quickly implement a simple chatbot that utilizes LangChain for memory management.

Implementation

Dependencies

To begin, we'll set up a project directory and create a virtual environment where we can install the necessary dependencies. Here’s how to get started:

mkdir my_chatbot
cd my_chatbot
python -m venv venv
source venv/bin/activate  # On Windows use: venv\Scripts\activate

Installing Dependencies

After activating your virtual environment, the next step is to install the required libraries. We will mainly be using LangChain and the AI21 API. You can install them using pip:

pip install langchain ai21

Coding Time!

Now it’s time to start coding our chatbot. Begin by creating a .env file in your project directory to store your API key from AI21 Labs. This key will allow us to send requests to the AI21 model.

echo "AI21_API_KEY=your_api_key_here" > .env

Creating the Main File

Create a new file named main.py in your project directory. This file will contain all the code for our chatbot. Start by importing the necessary modules and loading your API key:

import os
from langchain import LLMChain
from langchain.memory import ConversationBufferMemory
import ai21  

# Load API Key
from dotenv import load_dotenv
load_dotenv()
api_key = os.getenv("AI21_API_KEY")

Setting Up the Chatbot

For the purpose of this tutorial, we will create a straightforward chatbot that runs in the terminal. You can customize and expand this application as needed. Start by setting up a prompt template to guide the model:

prompt_template = "You are a helpful assistant. How can I assist you today?"
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)

Next, instantiate the LLM chain to handle the conversation:

llm_chain = LLMChain(llm=ai21.AI21(api_key), prompt=prompt_template, memory=memory, verbose=True)

Creating the Main Loop

The next step is to implement the main loop for the chatbot. This loop will allow the user to input text and receive responses:

while True:
    user_input = input("You: ")
    if user_input.lower() == 'exit':
        break
    response = llm_chain.run(input=user_input)
    print(f"AI: {response}")

Results

Now that we've set up our chatbot, it's time to run the application!

python main.py

Once the application is running, you can have a conversation with your AI chatbot. The chatbot retains memory of your previous interactions, which enhances the overall flow of conversation. You'll notice how the memory works seamlessly, allowing for a richer user experience.

Testing the Application

To test the functionality, initiate a conversation. As you continue chatting, observe how the chatbot remembers the context and responds accordingly:

You: Hello!
AI: You are a helpful assistant. How can I assist you today?
You: Tell me a joke!
AI: Why did the scarecrow win an award? Because he was outstanding in his field!

Conclusion

Implementing a chatbot using AI21 Labs and LangChain is not only straightforward but also highly effective in creating responsive applications. This tutorial has outlined the essential steps to set up your own chatbot with conversation memory in place. I encourage you to engage with other developers and explore further during the Plug into AI with AI21 Hackathon! Happy coding!