Forem: Rasswanth Shankar

Lyzr-Automata powered README Generation

Rasswanth Shankar — Wed, 17 Apr 2024 12:07:48 +0000

READMEs are crucial for clear communication and project understanding, but creating them can be a time-consuming chore. In this blog post, we’ll explore how we can leverages Lyzr-Automata’s capabilities to transform a file of code into clear, concise, and informative READMEs.

Setup

Create a folder, set up a virtual environment and activate it. Create .env file with your OPENAI_API_KEY. Then install the following libraries to get started.

Libraries

streamlit: for building the web app interface.
lyzr_automata : for implementing our AI models, and tasks.
dotenv: for loading environment variables (API key).

git+https://github.com/LyzrCore/lyzr-automata.git@main
streamlit==1.33.0
python-dotenv==1.0.1

Getting Started

1.Import Libraries

import streamlit as st
from lyzr_automata.ai_models.openai import OpenAIModel
from lyzr_automata import Agent, Task
from lyzr_automata.tasks.task_literals import InputType, OutputType

from dotenv import load_dotenv
import os

load_dotenv()

# Load OpenAI API Key
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")

2. generate_readme_file Function

OpenAIModel — Create our models using OpenAI Key and specify the model type and name. (GPT-4)
Agent — readme_agent, create a Lyzr Agent for readme generation.
Task — readme_creator_task, create Lyzr Task with instructions and input to generate readme file.

# Function to generate readme file
def generate_readme_file(file_contents, output_headers):
    # Initialize OpenAI Text Model
    open_ai_model_text = OpenAIModel(
    api_key=OPENAI_API_KEY,
    parameters={
        "model": "gpt-4-turbo-preview",
        "temperature": 0.2,
        "max_tokens": 4000,
        },
    )
    # Create a markdown generator Agent
    readme_agent = Agent(
        prompt_persona="You are an intelligent agent that can write in markdown format, but do not include ```markdown in the output.",
        role="Readme Generator"
    )
    # Create a markdown generator Task
    readme_creator_task = Task(
        name="Generate Readme Task",
        agent=readme_agent,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
        model=open_ai_model_text,
        instructions="Write a README file for the provided code. Return only the output. Headers to be included are: " + output_headers,
        log_output=True,
        enhance_prompt=False,
        default_input=file_contents,
    ).execute()

    with open("generated_file.md", "w") as my_file:
        my_file.write(readme_creator_task)

    return readme_creator_task

3. Input Components

st.file_uploader — To upload code file.
st.text_area — Text area to enter headers required
st.button — Button to submit inputs

# File uploader input
code_file = st.file_uploader("Upload your .py file")

# Headers input
output_headers = st.text_area("Headers to include", '''1. Title
2. Overview
3. Dependencies
4. Flow of the code in a bulleted format with 1-2 sentences each point.
5. How to run
''')

# Submit button
submit_file = st.button("Submit")

if submit_file:
    file_contents = code_file.read() # Read file
    readme_content = generate_readme_file(file_contents, output_headers) # Generate Readme file
    st.write(readme_content) # Print output
    st.download_button('Download readme', readme_content, file_name="generated_readme.md", mime="text/markdown") # Download output

Run App

streamlit run main.py

Flow Diagram

Want to create more of such amazing AI Workflows? Visit our website at GitHub to learn more about Lyzr-Automata!

Also checkout Lyzr SDKs at GitHub

Lyzr Website: Lyzr.ai
Lyzr Community Channel: Discord

Code: https://github.com/rasswanth-lyzr/readme_generator
Video Walkthrough:
Demo: https://rasswanth-lyzr-readme-generator-main-mchxnr.streamlit.app/

Optimizing Classroom Time: Using Lyzr-Automata to Generate Effective Timetables

Rasswanth Shankar — Tue, 16 Apr 2024 05:30:24 +0000

Juggling teacher availability, student needs, and subject requirements for your classroom can be quite a hassle. But what if there was a way to take the stress out of scheduling? In this blog post, we'll explore how Lyzr-Automata can help you build efficient, balanced, and fair timetables that meet the needs of your students and teachers.

Setup

Create a folder, set up a virtual environment and activate it. Create .env file with your OPENAI_API_KEY. Then install the following libraries to get started.

Libraries

streamlit: for building the web app interface.
lyzr_automata : for implementing our AI models, and tasks.
dotenv: for loading environment variables (API key).

lyzr-automata==0.1.2
streamlit==1.33.0
python-dotenv==1.0.1

Getting Started

We will split the task into 2 files. One for frontend components (main.py) while the other for Lyzr-Automata (lyzr_functions.py)

main.py

1.Import Libraries

import streamlit as st
from lyzr_functions import generate_basic_timetable

2. Input Components

st.text_area — Text area to enter timeslots, subjects list and constraints.
st.button — Button to submit input

# Time Slots
timeslot_input = st.text_area(
    "TIMESLOTS",
    '''08:00 AM - 09:00 AM
09:15 AM - 10:15 AM
10:30 AM - 11:30 AM
11:45 AM - 12:45 PM
01:00 PM - 02:00 PM
02:15 PM - 03:15 PM
03:30 PM - 04:30 PM
04:45 PM - 05:45 PM'''
)

# Subjects
subjects_input = st.text_area(
    "SUBJECTS",
    '''Mathematics
Science
English
Social Studies
History
Geography
Physical Education
Computer
Art
Music'''
)

# Constraints
constraints_input = st.text_area(
    "CONSTRAINTS",
    '''1. Mathematics - 5 classes a week
2. Science - 5 classes a week
3. English - 4 classes a week
4. Social Studies - 4 classes a week
5. History - 3 classes a week
6. Geography - 3 classes a week
7. Physical Education - 4 classes a week
8. Computer - 5 classes a week
9. Art - 2 class a week
10. Music - 2 class a week
11. Each classroom is allocated once per time slot on any given day.
12. Same subjects cannot be assigned consecutively'''
)

# Submit button
submit_inputs = st.button("Submit", type="primary")

3. Handle Inputs

if submit_inputs:
    # Save inputs to a file
    with open("example_slot.txt", "w") as my_file:
        my_file.write("TIMESLOTS")
        my_file.write("\n \n")
        my_file.write(timeslot_input)
        my_file.write("\n \n")

        my_file.write("SUBJECTS")
        my_file.write("\n \n")
        my_file.write(subjects_input)
        my_file.write("\n \n")

        my_file.write("CONSTRAINTS")
        my_file.write("\n \n")
        my_file.write(constraints_input)

    # Call timetable generator
    generate_basic_timetable()

    # Read and display from result file
    with open("example_result.txt", "r") as my_file:
        content = my_file.read()

    st.write(content)

lyzr_functions.py

1.Import Libraries

from lyzr_automata.ai_models.openai import OpenAIModel
from lyzr_automata.memory.open_ai import OpenAIMemory
from lyzr_automata import Agent, Task
from lyzr_automata.tasks.task_literals import InputType, OutputType

from dotenv import load_dotenv
import os

load_dotenv()

OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")

2. Initialize Model and Memory

OpenAIModel — Create our models using OpenAI Key and specify the model type and name.
OpenAIMemory — timetable_memory, Create a memory of instructions for the agent.

# OpenAI Text Model
open_ai_model_text = OpenAIModel(
api_key=OPENAI_API_KEY,
parameters={
    "model": "gpt-4-turbo-preview",
    "temperature": 0.1,
    "max_tokens": 4096,
    },
)

# OpenAI Memory file
timetable_memory = OpenAIMemory(
    file_path='example_slot.txt'
)

3. generate_basic_timetable functions

Agent — timetable_agent, Lyzr Agent with instructions and persona to create timetable.
Task — timetable_task, Lyzr Task to create timetable.
Agent — timetable_checker_agent, Lyzr Agent with instructions and persona to verify timetable.
Task — timetable_checker_task, Lyzr Task to verify if the timetable is valid.

def generate_basic_timetable():
    # Remove file if exists
    if os.path.exists("assistant_ids.json"):
        os.remove("assistant_ids.json")

    # Timetable generator Agent
    timetable_agent = Agent(
        prompt_persona="You are an intelligent agent that can create efficient class timetables for a week in a simple, structured format. Do not assign more classes than required, assign free slots instead. Generate timetable for every day from Monday to Friday.",
        role="Timetable creator",
        memory=timetable_memory
    )

    # Timetable generator Task
    timetable_task = Task(
        name="Timetable Creator",
        agent=timetable_agent,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
        model=open_ai_model_text,
        instructions="Using the time slots, subject details and requirements, create a timetable that satisfies every constraint. Return the timetable in a simple format and a count of number of classes scheduled for each subject.",
        log_output=True,
        enhance_prompt=False,
    ).execute()

    # Save output to a file
    with open("example_result.txt", "w") as my_file:
        my_file.write("# GENERATED TIMETABLE - Timetable Agent")
        my_file.write("\n \n")
        my_file.write(timetable_task)
        my_file.write("\n")

    # Timetable verification Agent
    timetable_checker_agent = Agent(
        prompt_persona="You are an intelligent agent that can verify if a generated timetable fulfills all the constraints or not. Make sure all classes meet the exact requirements; not more, not less.",
        role="Timetable checker",
        memory=timetable_memory
    )

    # Timetable verification Task
    timetable_checker_task = Task(
        name="Timetable Checker",
        agent=timetable_checker_agent,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
        model=open_ai_model_text,
        instructions="Verify that the generated timetable input fulfills the requirements mentioned in the file. If VALID, return <!VALID!> and the timetable in a table format; If INVALID, return <!INVALID!> the reason why invalid. Do not return anything else.",
        log_output=True,
        enhance_prompt=False,
        previous_output=timetable_task
    ).execute()

    # Save output to a file
    with open("example_result.txt", "a") as my_file:
        my_file.write("\n \n")
        my_file.write("# GENERATED VERIFICATION - Verification Agent")
        my_file.write("\n \n")
        my_file.write(timetable_checker_task)
        my_file.write("\n")

Run App

streamlit run main.py

Flow Diagram

Want to create more of such amazing AI Workflows? Visit our website at GitHub to learn more about Lyzr-Automata!

Also checkout Lyzr SDKs at GitHub

Lyzr Website: Lyzr.ai
Lyzr Community Channel: Discord

Code: https://github.com/rasswanth-lyzr/timetable_bot
Video Walkthrough: https://youtu.be/h9c-bL0a3TM
Demo: https://rasswanth-lyzr-timetable-bot-main-n3n6ul.streamlit.app/

Get Hired Faster: How to use Lyzr-Automata to draft personalised cold emails

Rasswanth Shankar — Fri, 05 Apr 2024 07:30:32 +0000

In today’s competitive job market, getting noticed by recruiters can feel like finding a needle in a haystack. What if there was a way to cut through the noise and land yourself more interviews, faster? In this blog post, we’ll explore how Lyzr-Automata can empower job seekers to accelerate their job search and increase interview callbacks.

Setup

Create a folder, set up a virtual environment and activate it. Create .env file with your OPENAI_API_KEY. Then install the following libraries to get started.

Libraries

streamlit: for building the web app interface.
lyzr_automata : for implementing our AI models, and tasks.
dotenv: for loading environment variables (API key).

lyzr-automata==0.1.2
streamlit==1.32.2
python-dotenv==1.0.1

Getting Started

We will split the task into 2 files. One for frontend components (main.py) while the other for Lyzr-Automata (lyzr_functions.py)

main.py

1.Import Libraries

import streamlit as st
from pypdf import PdfReader 
import os
from lyzr_functions import send_cold_email

2.Helper Functions

# Save information on a text file that acts as memory for LLM
def save_to_text_file(text_value, mode):
    data_directory = "data"
    os.makedirs(data_directory, exist_ok=True)

    text_file_path = os.path.join(data_directory, 'instructions.txt')
    with open(text_file_path, mode) as file:
        file.write(text_value)

# Parse Resume
def read_pdf(pdf_file_path):
    reader = PdfReader(pdf_file_path) 
    extracted_text = ''.join(page.extract_text() for page in reader.pages)
    return extracted_text

3. Input Components

st.file_uploader — Upload Resume
st.text_area — Text area to enter job description
st.text_input — Text field to enter list of emails and contact info
st.button — Button to submit input

# Resume Input
uploaded_file = st.file_uploader("Upload Resume", type='pdf')

# Job description Input
job_description = st.text_area("Enter Job Description")

# List of emails to send Input
email_ids = st.text_input('List of Emails', placeholder='Email1, Email2,...')

# Name and contact to sign the email Input
contact_info = st.text_input('Your contact info (to sign the email)', placeholder='Name, Phone Number')

# Submit button Input
is_send_email = st.button('Send Email!')

# env Variables to send email
user_email_address = st.text_input('Your email address')
app_password = st.text_input('Your email app password')

4. Handle Inputs

if is_send_email:
    # If fields are empty
    if not email_ids or not job_description or not uploaded_file or not contact_info or not user_email_address or not app_password:
        st.error('Enter all the fields!')
    else:
        os.environ["PASSWORD"] = app_password
        os.environ["EMAIL"] = user_email_address
        email_list = email_ids.split(',')
        email_list = [email.strip() for email in email_list] # make a list of emails
        extracted_pdf_text = read_pdf(uploaded_file) # parse pdf
        save_to_text_file(text_value = extracted_pdf_text, mode = "w") # save pdf in txt file
        save_to_text_file(text_value = "\nJob Description : \n" + job_description, mode = "a") # save job desctiption in txt file
        send_cold_email(email_list, contact_info) # send email using Lyzr Automata
        st.success("Email sent!")

lyzr_functions.py

1.Import Libraries

from lyzr_automata.ai_models.openai import OpenAIModel
from lyzr_automata import Agent, Task
from lyzr_automata.tasks.task_literals import InputType, OutputType
from lyzr_automata.memory.open_ai import OpenAIMemory
from lyzr_automata.pipelines.linear_sync_pipeline import LinearSyncPipeline
from lyzr_automata import Logger
from lyzr_automata.tools.prebuilt_tools import send_email_by_smtp_tool
from dotenv import load_dotenv
import os

load_dotenv()

# LOAD OUR API KEY
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
PASSWORD = os.getenv("PASSWORD")
EMAIL = os.getenv("EMAIL")

2. send_cold_email function

OpenAIModel — Create our models using OpenAI Key and specify the model type and name.
OpenAIMemory — email_writer_memory, Create a vector store memory for the agent.
Agent — email_writer_agent, create a Lyzr Agent for text email creation using the memory.
Task — email_writer_task, create Lyzr Task with instructions on writing the email and the agent.
Tool — email_sender_tool, initialise the pre-built email sender tool
Task — send_email_task, create another Lyzr Task that is going to send our email.
LinearSyncPipeline — Pass the Tasks in order of execution.

def send_cold_email(email_list, contact_info):
    # GPT 4 Text Model
    open_ai_model_text = OpenAIModel(
        api_key= OPENAI_API_KEY,
        parameters={
            "model": "gpt-4-turbo-preview",
            "temperature": 0.3,
            "max_tokens": 1500,
        },
    )

    # Load memory from instructions file
    email_writer_memory = OpenAIMemory(
        file_path='data/instructions.txt'
    )

    # Create Agent with Memory
    email_writer_agent = Agent(
        prompt_persona="You are an intelligent email writer agent and assume the persona of a job seeker reaching out to potential employers or recruiters. The email should be professional, concise, and persuasive, highlighting the candidate's skills, experience, and why they are a good fit for the job description.",
        role="Cold Email writer",
        memory=email_writer_memory
    )

    # Create email writer Task
    email_writer_task = Task(
        name="Cold Email Creator",
        agent=email_writer_agent,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
        model=open_ai_model_text,
        instructions="Use the resume information and job description to write a cold email of 250 words to be sent to the recruiter. [IMPORTANT!] send the response in html use bullets for points and beautify it professionally. Return only the email. Don't leave any field empty. My personal details are : " + contact_info,
        log_output=True,
        enhance_prompt=False,
    )

    # Initialize email sender Tool
    email_sender_tool = send_email_by_smtp_tool(
        username=EMAIL,
        password=PASSWORD,
        host="smtp.gmail.com",
        port=587,
        sender_email=EMAIL
    )

    # Create email sender Task
    send_email_task = Task(
        name = "Send Email Task",
        tool = email_sender_tool,
        instructions="Send Email",
        model=open_ai_model_text,
        input_tasks = [email_writer_task],
        default_input = email_list
    )

    # Run Tasks using a pipeline
    logger = Logger()
    LinearSyncPipeline(
        logger=logger,
        name="Cold Emailer",
        completion_message="Email Sent!",
        tasks=[
            email_writer_task,
            send_email_task
        ],
    ).run()

Run App

streamlit run main.py

Flow Diagram

Want to create more of such amazing AI Workflows? Visit our website at GitHub to learn more about Lyzr-Automata!

Also checkout Lyzr SDKs at GitHub

Lyzr Website: Lyzr.ai
Lyzr Community Channel: Discord

Code: https://github.com/rasswanth-lyzr/cold-emailer
Video Walkthrough: https://www.youtube.com/watch?v=hXLAN0qFP9g

Boost Your Filmmaking Workflow: Create Storyboards and Write Scenes using Lyzr-Automata

Rasswanth Shankar — Wed, 27 Mar 2024 04:45:37 +0000

Ever stare at your script or storyboard feeling like nothing clicks? We all hit our creative rut and some point. But what if you can make use of AI to break free? In this blog post, we’ll take a look how Lyzr-Automata can help us with it.

Setup

Create a folder, set up a virtual environment and activate it. Create .env file with your OPENAI_API_KEY. Then install the following libraries to get started.

Libraries

streamlit: for building the web app interface.
lyzr_automata : for implementing our AI models, and tasks.
dotenv: for loading environment variables (API key).

lyzr-automata==0.1.2
streamlit==1.32.2
python-dotenv==1.0.1

Getting Started

1.Import Libraries

from lyzr_automata.ai_models.openai import OpenAIModel
from lyzr_automata import Agent, Task
from lyzr_automata.tasks.task_literals import InputType, OutputType
from lyzr_automata.pipelines.linear_sync_pipeline  import  LinearSyncPipeline
from lyzr_automata import Logger

from dotenv import load_dotenv
import os

import streamlit as st

load_dotenv()

# LOAD OUR API KEY
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")

2. Setup interface using Streamlit

st.text_area — Text area to enter scene description (Link)
st.button — Button to submit input (Link)
st.write — Display text (Link)
st.image — Display an image (Link)

input_scene = st.text_area("Enter Scene Description")

button=st.button('Submit')
if (button==True):
    # CALL FUNCTION TO GENERATE OUTPUT
    generated_output = storyboard_generator(input_scene)

    # DISPLAY OUTPUT
    text_output = generated_output[0]['task_output']
    st.write(text_output)
    image_file_name = generated_output[1]['task_output'].local_file_path
    st.image(image_file_name, caption='Storyboard')

3. Create our AI Models

OpenAIModel — Create our models using OpenAI Key and specify the model type and name.

# DALLE 3 Image Model
open_ai_model_image = OpenAIModel(
    api_key=OPENAI_API_KEY,
    parameters={
        "n": 1,
        "model": "dall-e-3",
    },
)

# GPT 4 Text Model
open_ai_model_text = OpenAIModel(
    api_key= OPENAI_API_KEY,
    parameters={
        "model": "gpt-4-turbo-preview",
        "temperature": 0.5,
        "max_tokens": 1500,
    },
)

4. Storyboard Generator Function

Agent — screenplay_writer_agent, create a Lyzr Agent for text creation and set persona.
Task — screenplay_content_task, create Lyzr Task with scene description input, instructions and Text Agent. Define Input and Output types as well.
Task — storyboard_creation_task, create another Lyzr Task with scene description input, instructions and Image Model.
LinearSyncPipeline — Pass the Text Task first followed by the Image Task, enabling them to execute in sequence and ensure flow of data.

def storyboard_generator(input_content):
    # Screenplay Writer Agent
    screenplay_writer_agent = Agent(
        prompt_persona="You are an intelligent Screenplay writer good at writing a short and detailed scene",
        role="Screenplay writer",
    )

    # Write Screenplay Task
    screenplay_content_task = Task(
        name="Screenplay Content Creator",
        agent=screenplay_writer_agent,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
        model=open_ai_model_text,
        instructions="Use the scene description provided and write 4 shots for a movie in 200 words. Use your creativity. [IMPORTANT!] Setup the location and characters in a detailed manner",
        log_output=True,
        enhance_prompt=False,
        default_input=input_content
    )

    # Generate Storyboard
    storyboard_creation_task = Task(
        name="Storyboard Image Creation",
        output_type=OutputType.IMAGE,
        input_type=InputType.TEXT,
        model=open_ai_model_image,
        log_output=True,
        instructions="Generate a set of 4 storyboard drawings for the given scene description. Capture every detail. Minimalistic style. [IMPORTANT!] Avoid any text or numbers in the image.",
    )

    logger = Logger()
    # Linear Pipeline to run tasks
    main_output = LinearSyncPipeline(
        logger=logger,
        name="Generate Storyboard",
        completion_message="Storyboard Generated!",
        tasks=[
            screenplay_content_task,
            storyboard_creation_task,
        ],
    ).run()

    return main_output

5. Run App

streamlit run <app_name.py>

OUTPUT

My Input = “a man and woman argue in an alley while i watch it and walk past”

Flow Diagram

Want to create more of such amazing AI Workflows? Visit our website at GitHub to learn more about Lyzr-Automata!

Also checkout Lyzr SDKs at GitHub

Lyzr Website: Lyzr.ai
Lyzr Community Channel: Discord

Code: https://github.com/LyzrCore/lyzr-automata/tree/main/examples/storyboard_generator
Video Walkthrough: https://tella.video/storyboard-generator-8fpi

Meeting Minutes Made Easy: Summarize Key Points and Send Emails using Lyzr-Automata

Rasswanth Shankar — Mon, 18 Mar 2024 03:37:24 +0000

After every single meeting, capturing action items, summarizing key decisions, and keeping everyone in the loop with follow-up emails can be a time-consuming hassle. In this blog post, we’ll delve into the innovative workflow using Lyzr-Automata designed to summarize meetings and send email reports seamlessly.

Before We Begin

Before we start, we need to get an Access Token to call Microsoft Graph API. Graph API is what we’ll be using to retrieve content and emails.

Steps to get Access Token and basic python setup template — LINK

Documentation of Graph API — LINK

We will be mainly using 2 APIs from Microsoft Graph

Get callTranscript — To get the transcript of a particular meeting
List attendanceRecords — To list all the attendees in a meeting

Now let’s look at how to automate the process using Lyzr-Automata, given that we have retrieved results from these 2 APIs.

Setup

Create a folder, set up a virtual environment and activate it

virtualenv my_env
source my_env/bin/activate

Install the following packages

lyzr-automata==0.1.2
python-dotenv==1.0.1

Setup .env file

OPENAI_API_KEY = "YOUR OPENAI API KEY"
EMAIL = "YOUR EMAIL ID"
PASSWORD = "YOUR APP PASSWORD"

Note: To get your App Password, follow these steps here

Get Started

1.APIs to fetch data (token is the Microsoft Access Token)

# Transcript API
def get_transcript_content(meeting_ID, transcript_ID, token):
    endpoint = "https://graph.microsoft.com/v1.0/me/onlineMeetings/{meeting}/transcripts/{transcript}/content?$format=text/vtt".format(meeting = meeting_ID, transcript = transcript_ID)
    api_result = requests.get(
        endpoint,
        headers={'Authorization': 'Bearer ' + token['access_token']},
        timeout=30,
    ).text
    return api_result

# Attendees API
def get_attendees_list(meeting_ID, report_ID, token):
    endpoint = "https://graph.microsoft.com/v1.0/me/onlineMeetings/{meeting}/attendanceReports/{report}/attendanceRecords".format(meeting = meeting_ID, report = report_ID)
    api_result = requests.get(
        endpoint,
        headers={'Authorization': 'Bearer ' + token['access_token']},
        timeout=30,
    ).json()

    attendance_values = api_result["value"]
    email_list = []
    for attendee in attendance_values:
        if attendee["emailAddress"]:
            email_list.append(attendee["emailAddress"])
    return email_list

2.Load .env variables

from dotenv import load_dotenv
import os
from lyzr_automata.ai_models.openai import OpenAIModel
from lyzr_automata import Agent
from lyzr_automata import Task
from lyzr_automata.tasks.task_literals import InputType, OutputType
from lyzr_automata.tools.prebuilt_tools import send_email_by_smtp_tool

load_dotenv()

OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
EMAIL = os.getenv("EMAIL") # Email ID to send emails from
PASSWORD = os.getenv("PASSWORD") # App password of the email

3.Initialize Text Model

# GPT 4 Text Model
open_ai_model_text = OpenAIModel(
    api_key= OPENAI_API_KEY,
    parameters={
        "model": "gpt-4-turbo-preview",
        "temperature": 0.2,
        "max_tokens": 1500,
    },
)

4.Create our Summarizer

# Intructions for our Agent
summarizer_agent = Agent(
        prompt_persona="You are an intelligent agent that can summarize WebVTT content into a meaninful summary",
        role="WebVTT summarizer",
    )

input_transcript = get_transcript_content(meeting_ID, transcript_ID, token)

def email_draft_function(input_transcript):
    # Draft a summary Task
    summarize_content_task = Task(
        name="Transcript summarizer",
        agent=summarizer_agent,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
        model=open_ai_model_text,
        instructions="Summarize the WebVTT input into a meaningful Minutes of Meeting that captures immportant details and speakers. Return only the speaker name and their corresponding suammary [!IMPORTANT] Use HTML table to revise the email and beautify it", # Prompt Engineering
        log_output=True,
        enhance_prompt=False,
        default_input=input_transcript # Input for the task
    ).execute()

    return summarize_content_task # Return Output

5.Send Email Task

input_email_list = get_attendees_list(meeting_ID, report_ID, token)

# Email config
def email_sender_function(summarize_content_task, input_email_list):
    email_sender = send_email_by_smtp_tool(
        username=EMAIL,
        password=PASSWORD,
        host="smtp.gmail.com",
        port=587,
        sender_email=EMAIL
    )

    # Send email Task
    send_email_task = Task(
        name = "Send Email Task",
        tool = email_sender,
        instructions="Send Email",
        model=open_ai_model_text,
        input_tasks = [summarize_content_task],
        default_input = input_email_list,
        previous_output = summarize_content_task
    ).execute()

6. Setup your flask server and run!

FLOW Diagram

Want to create more of such amazing AI Workflows? Visit our website at GitHub to learn more about Lyzr-Automata!

Lyzr Website: https://www.lyzr.ai/
Lyzr Community Channel: Discord

Automate Email Newsletter with Lyzr-Automata

Rasswanth Shankar — Tue, 12 Mar 2024 10:31:29 +0000

Lyzr-Automata is a low-code multi-agent automation framework that enables us to break down complex tasks into simple agents and thread them together. In this blog post, we’ll create an Automated Newsletter Publisher using lyzr-automata.

Setup

Create a folder, set up a virtual environment and activate it

virtualenv my_env
source my_env/bin/activate

Install the following packages

lyzr-automata==0.1.2
python-dotenv==1.0.1

Setup .env file

OPENAI_API_KEY = "YOUR OPENAI API KEY"
EMAIL = "YOUR EMAIL ID"
PASSWORD = "YOUR APP PASSWORD"

Note: To get your App Password, follow these steps here

Get Started

Let’s create a file main.py and use that

1.Load .env variables

from dotenv import load_dotenv
import os

load_dotenv()

OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
PASSWORD = os.getenv("PASSWORD")
EMAIL = os.getenv("EMAIL")

2.Initialise our Model

A Text to Text model to create content (GPT-4)
A Text to Image model to create a suitable image (DALLE-3)

open_ai_model_text = OpenAIModel(
    api_key=OPENAI_API_KEY,
    parameters={
        "model": "gpt-4-turbo-preview", # Specify Model
        "temperature": 0.2, # Creativity of the model
        "max_tokens": 1500, # Maximum tokens
    },
)

open_ai_model_image = OpenAIModel(
    api_key=OPENAI_API_KEY,
    parameters={
        "n": 1, # Number of images
        "model": "dall-e-3", # Specify Model
    },
)

3.Build our agent

from lyzr_automata import Agent

content_researcher_agent = Agent(
    prompt_persona="You are an intelligent Travel Newsletter writer good at writing a detailed newsletter on a particular destination",
    role="Travel Newsletter writer",
)

4. Implement our Tasks

from lyzr_automata import Task
from lyzr_automata.tasks.task_literals import InputType, OutputType

# Newsletter Content Creator Task
research_task = Task(
    name="Draft Content Creator",
    agent=content_researcher_agent,
    output_type=OutputType.TEXT,
    input_type=InputType.TEXT,
    model=open_ai_model_text,
    instructions="Write a travel newsletter on Mumbai in 500 words and [IMPORTANT!] send the response in html use bullets for points and beautify it be as creative as you want.",
    log_output=True,
    enhance_prompt=False,
)

# Image Creator Task
image_creation_task = Task(
    name="Newsletter Image Creation",
    output_type=OutputType.IMAGE,
    input_type=InputType.TEXT,
    model=open_ai_model_image,
    log_output=True,
    instructions="Use the travel newsletter provided and create an image that would be suitable for posting. Avoid any text in the image",
)

# Merge Image and Content Task
merge_image_text_task = Task(
    name = "Merge Image and Email",
    model=open_ai_model_text,
    log_output=True,
    instructions="Include the image in the html code provided. Return only the HTML and CSS code",
    input_tasks = [research_task, image_creation_task]
)

5.Create our Email Sender Tool

from lyzr_automata.tools.prebuilt_tools import send_email_by_smtp_tool

email_sender = send_email_by_smtp_tool(
    username=EMAIL,
    password=PASSWORD,
    host="smtp.gmail.com",
    port=587,
    sender_email=EMAIL
)

send_email_task = Task(
    name = "Send Email Task",
    tool = email_sender,
    instructions="Send Email",
    model=open_ai_model_text,
    input_tasks = [merge_image_text_task],
    default_input = ["EMAIL1", "EMAIL2"] # Specify Reciever Email IDs HERE
)

6.Create Pipeline and execute the tasks

from lyzr_automata.pipelines.linear_sync_pipeline import LinearSyncPipeline
from lyzr_automata import Logger

def main_program():
    logger = Logger()
    LinearSyncPipeline(
        logger=logger,
        name="Send Email",
        completion_message="Email Sent!",
        tasks=[
            research_task,
            image_creation_task,
            merge_image_text_task,
            send_email_task
        ],
    ).run()

main_program()

7.Run the file and find the email in your inbox!

FLOW Diagram

And that’s a wrap. Feel free to play around with Lyzr-Automata on your own!

Lyzr-Automata Github
Code Link — LINK