Creating a Personal Assistant with LangChain: A Step-by-Step Guide

Creating a Personal Assistant with LangChain: A Step-by-Step Guide


Introduction

Large language models (LLMs), like ChatGPT, have rapidly transformed the way we work, even though they've only been around for a short time. With the power of generative AI, many tasks can now be automated, significantly improving productivity.

One of the most useful applications of an LLM is developing your own personal assistant, capable of handling repetitive or routine tasks efficiently.

In this article, I’ll guide you through the process of creating a personal assistant using LangChain, a tool that leverages LLMs to help automate and manage your daily tasks. Let’s dive in!


Table of Contents

Personal Assistant Development with LangChain

To develop a personal assistant with LangChain, follow these steps. We will cover the key components you need, including how to set up LangChain, configure the LLM, and integrate APIs for automation. This process assumes you have Python installed and the required libraries.

Step 1: Install LangChain and Dependencies

First, you need to install the necessary libraries. Run the following commands:

pip install langchain
pip install openai
pip install requests


You'll also need an OpenAI API key to interact with the GPT models, so make sure you have it ready.

Step 2: Set Up OpenAI API

Before you begin creating the personal assistant, configure the OpenAI API with your API key. Create a .env file in your project directory and store your API key like this:

OPENAI_API_KEY="your-openai-api-key"

 

These are the packages necessary for our project. Now, fill in the .env file with your OpenAI API key.

OPENAI_API_KEY=”SK-YOUR_API_KEY”

 

Now, in your Python script, load the environment variable and authenticate with OpenAI:

import openai
from dotenv import load_dotenv
import os

load_dotenv()  # Load the .env file

openai.api_key = os.getenv("OPENAI_API_KEY")

 

Step 3: Create a Simple Language Model Wrapper

Next, you’ll create a basic wrapper for the OpenAI GPT-3 model using LangChain’s tools. This will allow your personal assistant to process and respond to queries.

from langchain.chat_models import ChatOpenAI

# Initialize the OpenAI model with LangChain
llm = ChatOpenAI(model="gpt-3.5-turbo")

# Function to interact with the LLM
def ask_question(question):
    response = llm.call(question)
    return response

 

Step 4: Define Tasks for Your Assistant

Now, you can define specific tasks for your personal assistant. These tasks could range from scheduling reminders to fetching information from external APIs. For example, you can create a function to fetch weather data.

import requests

def get_weather(city):
    api_key = "your-weather-api-key"
    url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}"
    response = requests.get(url)
    data = response.json()
    
    if data["cod"] == 200:
        main = data["main"]
        weather = data["weather"][0]["description"]
        return f"The temperature in {city} is {main['temp']}°C with {weather}."
    else:
        return "City not found."

 

Step 5: Integrate Multiple Agents for Task Automation

LangChain allows you to link multiple agents together, enhancing your assistant's ability to complete complex workflows. For example, you can chain a query to get the weather and then use the result for other tasks, such as sending an email or setting a reminder.

from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

# Create a prompt template for a weather-related question
template = "What's the weather like in {city}?"
prompt = PromptTemplate(input_variables=["city"], template=template)

# Chain the prompt with the language model
chain = LLMChain(prompt=prompt, llm=llm)

# Function to process the task
def process_weather_task(city):
    result = chain.run({"city": city})
    return result

 

Step 6: Deploy and Use the Personal Assistant

Once you have the necessary tasks and agents set up, you can deploy your assistant as a script, web app, or API. You might want to integrate it with a UI (e.g., using Flask or FastAPI) or use a command-line interface for interaction. 

Example for running a simple CLI:

def main():
    while True:
        print("Ask your personal assistant:")
        query = input()
        
        if query.lower() == "exit":
            break
        
        if "weather" in query:
            city = query.split("in")[-1].strip()
            print(get_weather(city))
        else:
            print(ask_question(query))

if __name__ == "__main__":
    main()

 

This script allows you to interact with your personal assistant by asking questions or requesting tasks like checking the weather.

Step 7: Further Enhancements

To make your personal assistant more advanced, you can: 

  • Integrate more APIs for tasks like sending emails, managing calendars, or even controlling IoT devices. 
  • Use LangChain’s memory module to make your assistant more context-aware and improve task completion based on prior interactions.

Here’s the entire code in one block to create a personal assistant using LangChain and Streamlit.

# Import necessary libraries
import streamlit as st
import openai
import os
from dotenv import load_dotenv
from langchain.chat_models import ChatOpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

# Load the OpenAI API key from the .env file
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")

# Initialize the LangChain model with OpenAI
llm = ChatOpenAI(model="gpt-3.5-turbo")

# Define a simple function to create a LangChain
def create_personal_assistant_chain():
    prompt = PromptTemplate(
        input_variables=["question"],
        template="You are a personal assistant. Answer the question concisely: {question}"
    )
    return LLMChain(prompt=prompt, llm=llm)

# Create the chain
assistant_chain = create_personal_assistant_chain()

# Set up the Streamlit app interface
st.title("Personal Assistant with LangChain")
st.write("Ask me anything, and I'll help you out!")

# User input
user_question = st.text_input("Enter your question:")

# Response generation
if st.button("Get Answer"):
    if user_question:
        response = assistant_chain.run({"question": user_question})
        st.write("Response:", response)
    else:
        st.write("Please enter a question to get started.")

Ensure you have your OpenAI API key saved in a .env file as: 

OPENAI_API_KEY="your-openai-api-key" 

In your terminal, navigate to the directory containing app.py, then run: 

streamlit run app.py

This code will set up a web interface where you can input a question, and the assistant will respond based on the LangChain and OpenAI GPT-3.5 turbo model.

Conclusion

 
In this article, we have explored how to develop personal assistants with LLMs using LangChain. By setting up each task, LLM can act as an assistant for that specific assignment. Using an agent from LangChain, we can delegate them to select which task appropriate to run according to the context we pass. 

I hope this has helped!