DEV Community: Prajjwal Sule

Transform Your Text with Lyzr.ai: A Step-by-Step Guide

Prajjwal Sule — Tue, 06 Aug 2024 15:00:16 +0000

Writing is an essential part of our daily lives. Whether it's drafting emails, creating documents, or telling stories, we aim for clarity and accuracy. Yet, correcting errors with spell checkers can be challenging.

Enter AI proofreading, a fantastic tool designed to polish your text. Today, we'll explore simple code that uses AI to improve your writing, correcting grammar, spelling, punctuation, and formatting.

Problem Statement

Creating grammatically correct text is crucial but often difficult. Manual proofreading is time-consuming and can miss errors. This code uses Lyzr.ai to check and edit text, enhancing writing effectiveness.

Prerequisites

Before starting, you should understand Python programming and have access to the OpenAI API with an API key. Familiarity with installing and importing Python libraries and Lyzr.ai’s framework will also help.

Installing the Lyzr Automata Framework

pip install lyzr-automata

# For Google Colab or notebook
!pip install lyzr-automata

Code and Explanation

Let's break down the code step-by-step.

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

API_KEY = input('Enter OpenAI API Key')
text = input('Enter the Text Here: ')

We start by importing necessary tools from the Lyzr.ai library and prompt the user for their OpenAI API key and text to proofread.

open_ai_model_text = OpenAIModel(
    api_key=API_KEY,
    parameters={
        "model": "gpt-4-turbo-preview",
        "temperature": 0.5,
        "max_tokens": 1500,
    },
)

We set up the AI model with the API key and parameters, controlling the AI’s behavior and response length.

def ai_proofreader(text):
    ProofReader = Agent(
        prompt_persona="""You are an expert proofreader who can find grammatical errors, and you excel at checking for grammar, spelling, punctuation, and formatting errors.""",
        role="AI Proofreader",
    )

    rephrase_text = Task(
        name="Rephrasing Text",
        agent=ProofReader,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
        model=open_ai_model_text,
        instructions=f"Check the entire text: '{text}' and rephrase it according to grammar, spelling, punctuation, and formatting errors. [Important] Avoid introduction and conclusion in the response.",
        log_output=True,
        enhance_prompt=False,
        default_input=text
    )

    remarks = Task(
        name="Remarks",
        agent=ProofReader,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
        model=open_ai_model_text,
        instructions=f"Check the entire text: '{text}' and provide remarks in bullet points according to grammar, spelling, punctuation, and formatting errors. [Important] Avoid introduction and conclusion in the response.",
        log_output=True,
        enhance_prompt=False,
        default_input=text
    )

    logger = Logger()

    main_output = LinearSyncPipeline(
        logger=logger,
        name="AI ProofReader",
        completion_message="App Generated all things!",
        tasks=[
            rephrase_text,
            remarks,
        ],
    ).run()

    return main_output

We define a function called ai_proofreader. Inside, we create an agent named ProofReader, acting as an expert proofreader. Two tasks are created: one for rephrasing text and another for providing remarks. Both tasks use the ProofReader agent and the AI model.

A logger monitors the process. We then establish a pipeline that sequentially executes the tasks, yielding corrected text and remarks.

generated_output = ai_proofreader(text=text)
rephrased_text = generated_output[0]['task_output']
remarks = generated_output[1]['task_output']

We call the function with the user’s text and get the rephrased text and remarks as outputs.

Sample Input

text = """ I Rajesh have 2+ years of experience in python developer, 
I know to create backend applications, 
I am seeking a new role for new learnings """

Output

""" 
My name is Rajesh, and I possess over two years of experience as a Python developer. 
I am skilled in creating backend applications and am currently seeking a new role to further my learning 

- The phrase "I Rajesh have 2+ years of experience in python developer" should be corrected to "I, Rajesh, have over two years of experience as a Python developer." This correction addresses a punctuation issue (adding commas around "Rajesh"), a numerical expression ("2+" to "over two"), and clarifies the role ("in python developer" to "as a Python developer").
- "python" should be capitalized to "Python" to properly denote the programming language.
- The phrase "I know to create backend applications" could be more fluidly expressed as "I know how to create backend applications" or "I am skilled in creating backend applications" for clarity and grammatical correctness.
- The phrase "I am seeking a new role for new learnings" could be improved for clarity and professionalism. A better alternative might be "I am seeking a new role to further my learning" or "I am seeking a new role to continue my professional development."
- The entire passage could benefit from better punctuation and formatting for clarity and flow. For instance, using semicolons or periods to separate independent clauses can improve readability: "My name is Rajesh, and I possess over two years of experience as a Python developer; I am skilled in creating backend applications and am currently seeking a new role to further my learning."
- Consistency in tense and style would improve the professional tone of the passage.
"""

About Lyzr.ai

Lyzr.ai offers a low-code agent development kit for creating GenAI applications quickly. With this simple agent framework, you can build secure and reliable generative AI applications for various uses, including proofreading and writing.

References

For more information, visit Lyzr’s website, book a demo, or join the community channels on Discord and Slack.

Lyzr Website
Book a Demo
Lyzr Community Channels: Discord, Slack

AI Proofreader: GitHub

Simplify Restaurant Reservations with Lyzr.ai's Chatbot-Powered App

Prajjwal Sule — Wed, 01 May 2024 17:29:29 +0000

In the bustling world of restaurants, managing reservations efficiently is crucial for providing excellent customer service. To simplify this process, the Restaurant-Reservations app by Lyzr.ai offers an innovative solution powered by chatbot technology. This Streamlit-based application allows users to interact with a chatbot to handle restaurant reservations seamlessly. Let's explore how the app works and how it can revolutionize the way restaurants manage their reservations.

Introducing the Restaurant-Reservations App

The Restaurant-Reservations app leverages Lyzr's agent-centric approach to rapidly develop Large Language Model (LLM) applications with minimal code and time investment. Whether you're familiar with the GenAI stack or not, Lyzr empowers you to build AI applications effortlessly, making it the go-to solution for constructing GenAI apps without requiring an in-depth understanding of Generative AI.

Setting up the Project

Getting started with the Restaurant-Reservations app is easy. Follow these steps to set up the project:

Clone the App: Clone the Restaurant-Reservation app repository from GitHub.

   git clone https://github.com/PrajjwalLyzr/Restaurant-Reservation

Create and Activate Virtual Environment: Set up a virtual environment and activate it.

   python3 -m venv venv
   source venv/bin/activate

Create an Environment Variable: Create a .env file and add your OpenAI API key.

   OPENAI_API_KEY = "Paste your openai api key here"

You can obtain an OpenAI API key by visiting the OpenAI website.

Install Dependencies: Install the required dependencies.

   pip install lyzr streamlit docx2txt audio-recorder-streamlit

Utils Module for Common Functions

The utils.py file in the project serves as a utility module containing common functions utilized throughout the application. It includes functions for writing to and reading from a file to store chat history, as well as providing a system prompt for the chatbot.

import streamlit as st


def write_to_file(user_input, chatbot_response, file_path):
    with open(file_path, 'a') as file:
        file.write(f"User: {user_input}\n")
        file.write(f"Chatbot: {chatbot_response}\n")
        file.write("\n")


def read_chat_history(file_path):
    with open(file_path, 'r') as file:
        return file.readlines()


def system_prompt():
    sys_prompt = """
        Your name is Eva.
        You are the Manager at Gourmet Delight restaurant.
        You represent the Gourmet Delight restaurant.
        Output Length: Keep your answers less than 30 words so that it sounds more natural chat.
        Your Persona: Eva is a middle-aged woman born in the US. She is friendly, with a great sense of humor that is understated and professional, but she understands that making people comfortable includes using humor.
    """


    return str(sys_prompt)

Entry Point for the Application (`app.py`)

The app.py file defines the main functionality of the Restaurant-Reservations app using Streamlit. It sets up a temporary directory for storing chat history, configures the OpenAI API key, and defines functions for handling chatbot and voice interactions.

from utils import utils
import streamlit as st
from lyzr import ChatBot, VoiceBot
import os
from PIL import Image
from pathlib import Path
from dotenv import load_dotenv; load_dotenv()
from audio_recorder_streamlit import audio_recorder


tempDir = 'tempDir'
if not os.path.exists(tempDir):
    os.makedirs(tempDir)


file = 'responses.txt'


# setting up the OpenAI API Key
os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY')


#  ChatBot
def chatagent():
    chatbot = ChatBot.pdf_chat(
        input_files=[Path('./data/restaurant data.pdf')], system_prompt=utils.system_prompt(),
    )
    return chatbot


# Voice bot
def voiceagent(audio_bytes):
    voice = VoiceBot()
    if audio_bytes:
        st.audio(audio_bytes, format="audio/wav")
        # Save the recorded audio for transcription
        with open('tempDir/output.wav', 'wb') as f:
            f.write(audio_bytes)
        audiopath = 'tempDir/output.wav'
        if audiopath:
            user_input = voice.transcribe(audiofilepath='tempDir/output.wav')
            # st.write(user_input)

        chatbot = chatagent()
        response = chatbot.chat(user_input)
        voice.text_to_speech(response.response)
        utils.write_to_file(user_input=user_input, chatbot_response=response.response, file_path=file)
        # st.text(response.response)
        tts_audio_file = 'tts_output.mp3'
        if os.path.isfile(tts_audio_file):
            st.audio(tts_audio_file, format='audio/mp3', start_time=0)

    else:
        st.warning('Record your audio to start the conversation')


def delete_conversation():
        os.remove('tts_output.mp3')
        os.remove(file)
        st.warning('Record your audio to start the conversation')

Executing the Restaurant-Reservations Application

The Restaurant-Reservations app simplifies the process of handling restaurant reservations

Chatbot Interaction: Users can interact with the chatbot to make reservations by speaking.
Voice Interaction: The app supports voice input for a more convenient user experience.
Conversation History: Users can view and delete conversation history.

if __name__ == "__main__":
    audio_bytes = audio_recorder()
    voiceagent(audio_bytes)

    if os.path.exists(file):
        if st.button('Delete Conversation'):
            delete_conversation()

    if os.path.exists(file):
        chat_history = utils.read_chat_history(file_path=file)
        st.sidebar.subheader("Conversation History")
        for line in chat_history:
            st.sidebar.write(line.strip())

The Restaurant-Reservations app by Lyzr.ai offers a streamlined solution for managing restaurant reservations through chatbot technology. With its user-friendly interface and powerful features, it revolutionizes the way restaurants handle reservations. Try it out today and elevate your restaurant's reservation management!

References

Lyzr Website
Book a Demo
Lyzr Community Channels: Discord, Slack
Restaurant-Reservation GitHub Repository

Elevate Your Interview Preparation with the AI Interviewer App

Prajjwal Sule — Mon, 15 Apr 2024 19:18:23 +0000

In today's competitive job market, interview preparation is key to landing your dream job. To streamline this process, the AI Interviewer app offers an innovative solution by harnessing the power of artificial intelligence. Developed by Lyzr, this Streamlit-based application provides a seamless platform for extracting skills from your resume, generating tailored interview questions, and even providing reference answers. Let's dive into how the AI Interviewer app works and how you can leverage it to enhance your interview readiness.

Welcome to Lyzr! | Lyzr Documentation

Explore the limitless possibilities of Generative AI with Lyzr, an enterprise alternative to popular Generative AI SaaS products. Lyzr offers a robust and secure solution for building and launching your own enterprise-grade Generative AI applications with speed and confidence.

docs.lyzr.ai

The AI Interviewer app is designed to revolutionize interview preparation by leveraging AI capabilities. Powered by Lyzr's agent-centric approach, this application simplifies the process of generating interview questions and answers with minimal code and time investment.

Setting up the Project

Getting started with the AI Interviewer app is straightforward. Follow these steps to set up the project:

Clone the App: Clone the AI Interviewer app repository from GitHub.

   git clone https://github.com/PrajjwalLyzr/AI-Interviewer

Create a Virtual Environment: Set up a virtual environment and activate it.

   python3 -m venv venv
   source venv/bin/activate

Set Environment Variables: Create a .env file and add your OpenAI API key.

   OPENAI_API_KEY = “Paste your openai api key here”

Install Dependencies: Install the required dependencies.

   pip install lyzr streamlit

Core Components of the AI Interviewer App

Let's explore the key components of the AI Interviewer app:

Utils Module for Common Functions

The utils.py file in the project serves as a utility module containing common functions utilized throughout the application. It includes functions for removing existing files, retrieving files in a directory, and saving uploaded files.

import os
import shutil
from typing import Optional, Literal
import streamlit as st
from dotenv import load_dotenv; load_dotenv()


def remove_existing_files(directory):
    for filename in os.listdir(directory):
        file_path = os.path.join(directory, filename)
        try:
            if os.path.isfile(file_path) or os.path.islink(file_path):
                os.unlink(file_path)
            elif os.path.isdir(file_path):
                shutil.rmtree(file_path)
        except Exception as e:
            st.error(f"Error while removing existing files: {e}")




def get_files_in_directory(directory):
    # This function help us to get the file path along with filename.
    files_list = []


    if os.path.exists(directory) and os.path.isdir(directory):
        for filename in os.listdir(directory):
            file_path = os.path.join(directory, filename)

            if os.path.isfile(file_path):
                files_list.append(file_path)


    return files_list


def save_uploaded_file(uploaded_file, directory_name):
    # Function to save uploaded file
    remove_existing_files(directory_name)


    file_path = os.path.join(directory_name, uploaded_file.name)
    with open(file_path, "wb") as file:
        file.write(uploaded_file.read())
    st.success("File uploaded successfully")

Interface for Large Language Model (LLM) Calling

The llm_calling function serves as an interface for interacting with large language models (LLMs) provided by OpenAI. It facilitates text generation based on given prompts using specified parameters.

def llm_calling(
        user_prompt:str,
        system_prompt: Optional[str] = "You are a Large Language Model. You answer questions",
        llm_model: Optional[Literal['gpt-4-turbo-preview', 'gpt-4']] = "gpt-4-turbo-preview",
        temperature: Optional[float] = 1, # 0 to 2
        max_tokens: Optional[int] = 4095, # 1 to 4095
        top_p: Optional[float] = 1, # 0 to 1
        frequency_penalty: Optional[float] = 0, # 0 to 2
        presence_penalty: Optional[float] = 0 # 0 to 2
        ) -> str:
        if not (1 <= max_tokens <= 4095):
          raise ValueError("`max_tokens` must be between 1 and 4095, inclusive.")


        from openai import OpenAI
        client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))


        response = client.chat.completions.create(
        model=llm_model,
        messages=[
            {
            "role": "system",
            "content": f"{system_prompt}"
            },
            {
            "role": "user",
            "content": f"{user_prompt}"
            }
        ],
        temperature=temperature,
        max_tokens=max_tokens,
        top_p=top_p,
        frequency_penalty=frequency_penalty,
        presence_penalty=presence_penalty
    )


        return response.choices[0].message.content

Kernel for the AI Interviewer Application

The ai_interviewer function serves as the core of the AI Interviewer app. It utilizes the Lyzr library's QABot module to extract skills from either a PDF or a DOCX file and generate interview questions and answers accordingly.

from lyzr import QABot
from pathlib import Path
import os
from dotenv import load_dotenv


load_dotenv()


os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY')


def ai_interviewer(path, file):
    if file == '.pdf':
        interviewer_pdf = QABot.pdf_qa(
            input_files=[Path(path)]
        )

        return interviewer_pdf

    if file == '.docx':
        interviewer_doc = QABot.docx_qa(

            input_files=[Path(path)]
        )

        return interviewer_doc

Entry Point for the Application (`app.py`)

The app.py file defines the main functionality of the AI Interviewer app using Streamlit. It allows users to upload their resume in PDF or DOCX format, extracts skills, generates interview questions, and displays reference answers.

import streamlit as st
import os
from pathlib import Path
from PIL import Image
from utils import utils
from lyzr_qabot import ai_interviewer


data = "data"
os.makedirs(data, exist_ok=True)



def interviwer(path, filetype):
    interview_agent = ai_interviewer(path=path, file=filetype)
    metric = "Extract all the skills from the given file"
    skills = interview_agent.query(metric)

    return skills.response



def gpt_interview_questions(qabot_response):
    question_response = utils.llm_calling(user_prompt=f"Create one interview question on based on this skill set {qabot_response}, [!important] question should not more than 2 line make it very specific",
                                   system_prompt=f"You are an interview expert",llm_model="gpt-4-turbo-preview")


    answer_response = utils.llm_calling(user_prompt=f"Generate answer for this {question_response}, [!Important] answer should not more than 3 lines, make it simple",
                                   system_prompt=f"You are an interview expert",llm_model="gpt-4-turbo-preview")  

    return question_response, answer_response



def question_answer_session(typefile):
    path = utils.get_files_in_directory(data)
    filepath = path[0]
    qa_response = interviwer(path=filepath, filetype=typefile)
    question, gpt_answer = gpt_interview_questions(qabot_response=qa_response)
    st.header(question)
    st.markdown('---')
    st.subheader('Reference Answer')
    st.write(gpt_answer)

Executing the Application

def main():
    st.sidebar.image(image, width=150)
    file = st.sidebar.file_uploader("Upload your resume", type=["pdf", "docx"])
    if file is None:
        st.subheader('👈 Upload your resume to get started!!!')
        utils.remove_existing_files(data)


    if file is not None:
        utils.save_uploaded_file(file, directory_name=data)
        typefile = Path(file.name).suffix


        if st.sidebar.button('Next'):
            question_answer_session(typefile=typefile)

        st.sidebar.info('Click this 👆 Button to generate Interview Questions')


if __name__ == "__main__":
    main()

The AI Interviewer app offers a user-friendly interface for interview preparation:

Upload Resume: Users can upload their resume in PDF or DOCX format.
Generate Interview Questions: Upon uploading the resume, the app extracts skills and generates tailored interview questions.
View Reference Answers: Users can view reference answers corresponding to the generated interview questions.

Conclusion

AI Interviewer app, interview preparation becomes more efficient and effective. By leveraging AI capabilities, users can extract skills from their resumes and generate interview questions tailored to their expertise. Elevate your interview preparation today with the AI Interviewer app from Lyzr!

References

Revolutionize Education with Lyzr's Question-Answer Generator

Prajjwal Sule — Wed, 10 Apr 2024 13:58:59 +0000

In the realm of education, technology continues to play a pivotal role in transforming learning experiences and knowledge dissemination. One such innovation is the automation of question and answer generation, simplifying the creation of educational materials and assessments. In this article, we'll delve into the development of an application powered by Lyzr's QABot agent capabilities, enabling users to effortlessly generate questions and answers from educational content, particularly PDF files.

The Lyzr-Question Answer Generation app is a cutting-edge tool designed to assist educators and learners in generating insightful questions and comprehensive answers from educational content. Leveraging Lyzr's QABot agent, users can effortlessly extract valuable insights and enhance their learning experiences.

Lyzr

Lyzr offers an agent-centric approach to rapidly developing LLM (Large Language Model) applications with minimal code and time investment. Even if you’re unfamiliar with the GenAI stack, Lyzr empowers you to build your AI applications effortlessly. It is the go-to solution for constructing GenAI apps without requiring an in-depth understanding of Generative AI.

PDF Question-Answering with QABot | Lyzr Documentation

Welcome to the PDF question-answering realm with the pdf_qa function in Lyzr's QABot module. This powerful feature allows you to extract instant answers by asking questions on PDF documents, leveraging the capabilities of the Retrieval-Augmented Generation (RAG) model.

docs.lyzr.ai

Setting up the Project

Setting up the Question-Answer Generator project is simple. Follow these steps to get started:

Clone the App: Clone the Question-Answer Generator app repository from GitHub.

   git clone https://github.com/PrajjwalLyzr/Question-Generation

Create a Virtual Environment: Set up a virtual environment and activate it.

   python3 -m venv venv
   source venv/bin/activate

Set Environment Variables: Create a .env file and add your OpenAI API key.

   OPENAI_API_KEY = “Paste your openai api key here”

Install Dependencies: Install the required dependencies.

   pip install lyzr streamlit

Core Components of the Question-Answer Generator App

Let's explore the key components of Lyzr's Question-Answer Generator app:

Utils Module for Common Functions


import os
import shutil
from typing import Optional, Literal
import streamlit as st
from dotenv import load_dotenv; load_dotenv()


def remove_existing_files(directory):
    for filename in os.listdir(directory):
        file_path = os.path.join(directory, filename)
        try:
            if os.path.isfile(file_path) or os.path.islink(file_path):
                os.unlink(file_path)
            elif os.path.isdir(file_path):
                shutil.rmtree(file_path)
        except Exception as e:
            st.error(f"Error while removing existing files: {e}")




def get_files_in_directory(directory):
    # This function help us to get the file path along with filename.
    files_list = []
    if os.path.exists(directory) and os.path.isdir(directory):
        for filename in os.listdir(directory):
            file_path = os.path.join(directory, filename)  
            if os.path.isfile(file_path):
                files_list.append(file_path)

    return files_list


def save_uploaded_file(uploaded_file, directory_name):
    # Function to save uploaded file
    remove_existing_files(directory_name)

    file_path = os.path.join(directory_name, uploaded_file.name)
    with open(file_path, "wb") as file:
        file.write(uploaded_file.read())
    st.success("File uploaded successfully")

Interface for Large Language Model (LLM) Calling

def llm_calling(
        user_prompt:str,
        system_prompt: Optional[str] = "You are a Large Language Model. You answer questions",
        llm_model: Optional[Literal['gpt-4-turbo-preview', 'gpt-4']] = "gpt-4-turbo-preview",
        temperature: Optional[float] = 1, # 0 to 2
        max_tokens: Optional[int] = 4095, # 1 to 4095
        top_p: Optional[float] = 1, # 0 to 1
        frequency_penalty: Optional[float] = 0, # 0 to 2
        presence_penalty: Optional[float] = 0 # 0 to 2
        ) -> str:
        if not (1 <= max_tokens <= 4095):
          raise ValueError("`max_tokens` must be between 1 and 4095, inclusive.")


        from openai import OpenAI
        client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))


        response = client.chat.completions.create(
        model=llm_model,
        messages=[
            {
            "role": "system",
            "content": f"{system_prompt}"
            },
            {
            "role": "user",
            "content": f"{user_prompt}"
            }
        ],
        temperature=temperature,
        max_tokens=max_tokens,
        top_p=top_p,
        frequency_penalty=frequency_penalty,
        presence_penalty=presence_penalty
    )


        return response.choices[0].message.content

Kernel for Question Answer Generator Application

The question_generation function initializes a QABot instance configured to perform question generation from PDF files. It encapsulates the logic for setting up and initializing the QABot, providing a streamlined interface for generating questions from PDF documents.

import os
from lyzr import QABot
from dotenv import load_dotenv; load_dotenv()
from pathlib import Path

os.environ['OPENAI_API_KEY'] = os.getenv('OPENAI_API_KEY')


def question_generation(path):
    qa_bot = QABot.pdf_qa(
    input_files=[Path(path)],
    )

    return qa_bot

Entry Point for the Application (`app.py`)

The app.py file defines the core functionality of a Streamlit web application for generating questions and answers from a PDF document. It sets up the sidebar, provides options for selecting the PDF file source, and implements the logic for generating questions and answers based on user input.

import streamlit as st
import os
from PIL import Image
from utils import utils
from lyzr_qa import question_generation


data = "data"
os.makedirs(data, exist_ok=True)


def rag_response(topic, path):
    agent = question_generation(path)
    metric = f""" You are an expert of this {topic}. Tell me everything you know about this {topic}, Provide a detailed reponse on this {topic} from the given file"""
    response = agent.query(metric)
    return response.response


def gpt_questions(response, topic, number):
    response = utils.llm_calling(user_prompt=f"Develop some {number} numbers of questions on {response} that is clear, relevant, and specific which obeys the {topic}"
                                 f"[!important] Consider the context and purpose of the inquiry, aiming for open-endedness to encourage discussion or exploration. Engage the audience's curiosity while ensuring the question prompts meaningful responses",
                                   system_prompt=f"You are an expert of this {topic}",llm_model="gpt-4-turbo-preview")
    return response



def gpt_answers(questions, topic):
    answers = utils.llm_calling(user_prompt=f"""Provide a detailed response to the following {questions}, including relevant examples, explanations, and, if applicable, diagrams or code examples to illustrate your points. Additionally, consider discussing both the advantages and disadvantages of the topic to provide a comprehensive analysis.
                                Your answer should aim to offer a well-rounded understanding of the subject matter, highlighting its complexities and implications."""
                                , system_prompt=f'You are an expert of this {topic}', llm_model="gpt-4-turbo-preview")

    return answers

def main():
    st.sidebar.subheader('Lyzr- QnA Generator')

    selection = st.sidebar.radio("Select Any Option: ", ["Default File", "Upload File"])

    if selection == 'Default File':
        st.info('Default file: Object Oriented Programming')
        st.markdown(""" ##### Topics can be:
    1. Inheritance
    2. Polymorphsim
    3. Abstraction
    4. Encapsulation               """)
        path = './Object Oriented Programming.pdf'

        user_topic = st.text_input('Enter the topic according to subject')
        number_questions = st.text_input('Enter the number of questions')

        if user_topic is not None:
            if st.button('Submit'):
                rag_generated_response = rag_response(topic=user_topic, path=path)  # getting reponse from rag about the subject/topic
                gpt_response = gpt_questions(response=rag_generated_response, topic=user_topic, number=number_questions) # create n number of question on rag response
                gpt_answer = gpt_answers(questions=gpt_response, topic=user_topic) # create the answers for the questions
                st.subheader('Questions')
                st.write(gpt_response)
                st.markdown('---')
                st.subheader('Answers')
                st.write(gpt_answer)

    if selection == 'Upload File':
        file = st.file_uploader("Upload a Subject Book Pdf", type=["pdf"])
        if file:
            utils.save_uploaded_file(file, directory_name=data)
            path = utils.get_files_in_directory(directory=data)
            filepath = path[0] # get the first filepath

            user_topic = st.text_input('Enter the topic according to subject')
            number_questions = st.text_input('Enter the number of questions')

            if user_topic is not None:
                if st.button('Submit'):
                    rag_generated_response = rag_response(topic=user_topic, path=filepath)  # getting reponse from rag about the subject/topic
                    gpt_response = gpt_questions(response=rag_generated_response, topic=user_topic, number=number_questions) # create n number of question on rag response
                    gpt_answer = gpt_answers(questions=gpt_response, topic=user_topic) # create the answers for the questions
                    st.subheader('Questions')
                    st.write(gpt_response)
                    st.markdown('---')
                    st.subheader('Answers')
                    st.write(gpt_answer)

        else:
            st.warning('Please Upload subject pdf file!!!')


if __name__ == "__main__":
    main()

Executing the Application

The application offers a user-friendly interface for generating questions and answers:

Default File Option: Users can select predefined topics related to Object Oriented Programming and input a topic and specify the number of questions to generate.
Upload File Option: Users can upload a PDF document containing the subject matter, input the topic, and specify the number of questions.

Upon submission, the application generates questions and answers based on the selected topic and displays them for the user.

Lyzr's Question-Answer Generator, educators and learners can streamline the process of creating educational materials and assessments. By harnessing the power of AI, users can generate insightful questions and comprehensive answers from educational content with ease. Revolutionize education today with Lyzr.ai!

References

Interactive Audiobook GitHub Repository
Lyzr Website
Book a Demo
Lyzr Community Channels: Discord, Slack

Revolutionize Your Podcast Content Creation with Lyzr's Podcast Series Generator

Prajjwal Sule — Fri, 05 Apr 2024 13:14:41 +0000

In today's digital age, podcasts have emerged as a powerful medium for sharing knowledge, stories, and insights across various industries. However, creating engaging podcast content that resonates with your audience can be a daunting task. Lyzr.ai Automata's Podcast Series Generator – an innovative tool designed to streamline the process of generating tailored podcast series topics based on industry-specific themes and target audience preferences. In this article, we'll explore how this cutting-edge application harnesses advanced AI technology to revolutionize podcast content creation.

Lyzr

Welcome to Lyzr! | Lyzr Documentation

docs.lyzr.ai

Setting up the Project

Setting up the Podcast Series Generator project is straightforward. Follow these steps to get started:

Clone the App: Clone the Podcast Series Generator app repository from GitHub.

   git clone https://github.com/PrajjwalLyzr/Podcast-Series-Topics

Create a Virtual Environment: Set up a virtual environment and activate it.

   python3 -m venv venv
   source venv/bin/activate

Set Environment Variables: Create a .env file and add your OpenAI API key.

   OPENAI_API_KEY = "Paste your openai api key here"

Install Dependencies: Install the required dependencies.

   pip install lyzr-automata streamlit python-dotenv

Core Components of the Podcast Series Generator App

Let's delve into the key components of Lyzr's Podcast Series Generator app:

import os
import streamlit as st
from lyzr_automata.ai_models.openai import OpenAIModel
from lyzr_automata import Agent, Task, Logger
from lyzr_automata.tasks.task_literals import InputType, OutputType
from lyzr_automata.pipelines.linear_sync_pipeline import LinearSyncPipeline
from dotenv import load_dotenv

load_dotenv()

API_KEY = os.getenv('OPENAI_API_KEY')

open_ai_model_text = OpenAIModel(
    api_key= API_KEY,
    parameters={
        "model": "gpt-4-turbo-preview",
        "temperature": 0.5,
        "max_tokens": 1500,
    },
)

def podcast_series(industry, target_audience):

    content_strategist = Agent(
        prompt_persona="""You are a Content Strategist expert who craft a compelling podcast series tailored to our industry and target audience. Your mission is to delve deep into the nuances of our industry landscape and understand the interests and preferences of our target audience. Drawing upon your expertise in content analysis and audience research, you'll propose 10 engaging podcast topics that resonate with our audience's interests, challenges, and aspirations.""",
        role="Content Strategist",
    )


    podcast_topics_generator =  Task(
        name="Podcast Generator",
        agent=content_strategist,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
        model=open_ai_model_text,
        instructions=f"Use the description provided, Based on the {industry} and {target_audience}, suggest 5 episodes of 3 engaging topic for a podcast series. [IMPORTANT!] Setup the events in a detailed manner",
        log_output=True,
        enhance_prompt=False,
        default_input=industry
    )


    logger = Logger()

    main_output = LinearSyncPipeline(
        logger=logger,
        name="Podcast Series Topics",
        completion_message="App Generated all things!",
        tasks=[
            podcast_topics_generator,
        ],
    ).run()


    return main_output

Initializing the Application

The entry point of the Podcast Series Generator application prompts the user to input the industry and target audience for the podcast series through text input and text area components, respectively. Upon clicking the "Submit" button, it triggers the podcast_series function, passing the provided industry and target audience inputs.

if __name__ == "__main__":
    industry = st.text_input("Write down the industry")
    audience = st.text_area('Targeted Audience')


    button=st.button('Submit')
    if (button==True):
        generated_output = podcast_series(industry=industry, target_audience=audience)
        title_output = generated_output[0]['task_output']
        st.write(title_output)
        st.markdown('---')

The podcast_series function then generates a content roadmap based on the inputs, proposing 5 episodes, each containing 3 engaging podcast topics, tailored to the specified industry and target audience.

Conclusion

Lyzr's Podcast Series Generator, crafting engaging podcast content has never been easier. Empower your content strategy with AI-driven insights and generate compelling podcast topics that resonate with your audience's interests and aspirations. Revolutionize your podcasting journey today with Lyzr.ai Automata.

References

Podcast Series Generator GitHub Repository
Lyzr Website
Book a Demo
Lyzr Community Channels: Discord, Slack

Elevate Your Content Strategy with Lyzr's Content Campaign Generator

Prajjwal Sule — Thu, 04 Apr 2024 19:51:41 +0000

Crafting compelling content campaigns is essential for enhancing brand visibility and engagement in today's digital landscape. To streamline this process, Lyzr introduces the Content Campaign Generator, a powerful tool designed to create comprehensive content roadmaps tailored to your business goals and target audience. In this article, we'll explore how this innovative tool simplifies the content planning process and empowers digital marketers to drive success. This utilizes Lyzr Automata to generate a 3–5 month content roadmap.

Welcome to Lyzr! | Lyzr Documentation

Explore the limitless possibilities of Generative AI with Lyzr, an enterprise alternative to popular Generative AI SaaS products. Lyzr offers a robust and secure solution for building and launching your own enterprise-grade Generative AI applications with speed and confidence.

docs.lyzr.ai

Setting up the Project

Getting started with Lyzr's Content Campaign Generator is quick and easy. Follow these steps to set up the project:

Clone the App: Clone the Content Campaign Generator app repository from GitHub.

   git clone https://github.com/PrajjwalLyzr/Content-Campaign-Generator

Create a Virtual Environment: Set up a virtual environment and activate it.

   python3 -m venv venv
   source venv/bin/activate

Set Environment Variables: Create a .env file and add your OpenAI API key.

   OPENAI_API_KEY = "Paste your openai api key here"

Install Dependencies: Install the required dependencies.

   pip install lyzr-automata streamlit python-dotenv

Core Components of the Content Campaign Generator App

Let's explore the key components of Lyzr's Content Campaign Generator app:

import os
import streamlit as st
from lyzr_automata.ai_models.openai import OpenAIModel
from lyzr_automata import Agent, Task, Logger
from lyzr_automata.tasks.task_literals import InputType, OutputType
from lyzr_automata.pipelines.linear_sync_pipeline import LinearSyncPipeline
from dotenv import load_dotenv

load_dotenv()

API_KEY = os.getenv('OPENAI_API_KEY')

open_ai_model_text = OpenAIModel(
    api_key= API_KEY,
    parameters={
        "model": "gpt-4-turbo-preview",
        "temperature": 0.5,
        "max_tokens": 1500,
    },
)

def content_campaign_generator(campaign_goal, target_audience):

    digital_marketer_agent = Agent(
        prompt_persona="""You are an expert Digital Marketer and as a Digital Marketer expert, your mission is to craft and execute innovative digital marketing strategies that elevate brand visibility and drive customer engagement. Utilize your expertise in data analysis, SEO optimization, social media management, and content creation to create compelling campaigns that resonate with target audiences and propel brands to new heights in the digital landscape.""",
        role="Digital Marketer",
    )

    campaign_generator =  Task(
        name="Campaign Generator",
        agent=digital_marketer_agent,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
        model=open_ai_model_text,
        instructions=f"Use the description provided Outline a content roadmap with key topics and formats for a 5-month content marketing campaign, the Campaign Goal : {campaign_goal} for the Target Audience: {target_audience}. [IMPORTANT!] Setup the events in a detailed manner",
        log_output=True,
        enhance_prompt=False,
        default_input=campaign_goal
    )

    logger = Logger()

    main_output = LinearSyncPipeline(
        logger=logger,
        name="Content Campaign Generator",
        completion_message="App Generated all things!",
        tasks=[
            campaign_generator,
        ],
    ).run()

    return main_output

Initializing the Application

The entry point of the Content Campaign Generator application prompts the user to input the campaign goal and target audience via Streamlit text areas. Upon clicking the submit button, it triggers the content_campaign_generator function, passing the provided campaign goal and target audience as parameters.

if __name__ == "__main__":
    campaign = st.text_area("Campaign Goal")
    audience = st.text_area('Targeted Audience')

    button = st.button('Submit')
    if button:
        generated_output = content_campaign_generator(campaign_goal=campaign, target_audience=audience)
        title_output = generated_output[0]['task_output']
        st.write(title_output)
        st.markdown('---')

The function generates a content roadmap based on the inputs, outlining key topics and formats for a 5-month content marketing campaign tailored to the specified audience.

Conclusion

Lyzr's Content Campaign Generator, digital marketers can streamline the content planning process and craft innovative content strategies that elevate brand visibility and drive engagement. Embrace the power of AI to create comprehensive content roadmaps tailored to your business goals and target audience.

References

Content Campaign Generator GitHub Repository
Lyzr Website
Book a Demo
Lyzr Community Channels: Discord, Slack

Design Memorable Logos with Lyzr's Logo Generator

Prajjwal Sule — Thu, 04 Apr 2024 18:26:20 +0000

In today's competitive business landscape, a visually appealing and memorable logo is essential for establishing brand identity and attracting customers. Lyzr's Logo Generator offers an innovative solution to this challenge by harnessing the power of artificial intelligence to craft personalized logos tailored to users' specifications. In this article, we'll explore how this cutting-edge tool empowers businesses and individuals to create logos that reflect their unique identity and values.

Welcome to Lyzr! | Lyzr Documentation

Explore the limitless possibilities of Generative AI with Lyzr, an enterprise alternative to popular Generative AI SaaS products. Lyzr offers a robust and secure solution for building and launching your own enterprise-grade Generative AI applications with speed and confidence.

docs.lyzr.ai

Setting up the Project

To get started with Lyzr's Logo Generator, follow these steps:

Clone the App: Clone the Logo Generator app repository from GitHub.

   git clone https://github.com/PrajjwalLyzr/Logo-Generator

Create a Virtual Environment: Set up a virtual environment and activate it.

   python3 -m venv venv
   source venv/bin/activate

Set Environment Variables: Create a .env file and add your OpenAI API key.

   OPENAI_API_KEY = "Paste your openai api key here"

Install Dependencies: Install the required dependencies.

   pip install lyzr-automata streamlit python-dotenv

Structure

Logo-Generator
│
│
├── app.py
│
├── README.md
│
├── .gitignore
│
└── requirements.txt

Core Components of the Logo Generator App

Let's explore the key components of Lyzr's Logo Generator app:

import os
import streamlit as st
from lyzr_automata.ai_models.openai import OpenAIModel
from lyzr_automata import Agent, Task, Logger
from lyzr_automata.tasks.task_literals import InputType, OutputType
from lyzr_automata.pipelines.linear_sync_pipeline import LinearSyncPipeline
from dotenv import load_dotenv

load_dotenv()

API_KEY = os.getenv('OPENAI_API_KEY')

open_ai_model_image = OpenAIModel(
    api_key=API_KEY,
    parameters={
        "n": 1,
        "model": "dall-e-3",
    },
)

def logo_generator(user_specification):

    graphic_designer = Agent(
        prompt_persona="""As a seasoned Graphic Designer specializing in logo creation for brands, your mission is to visually communicate the essence and identity of each client through compelling and memorable designs. Leveraging your expertise in color theory, typography, and visual storytelling, you'll craft logos that resonate with target audiences and effectively represent the values and personality of each brand. Your goal is to create visually stunning and versatile logos that leave a lasting impression, elevating the presence and credibility of the brands you collaborate with.""",
        role="Graphic Designer",
    )


    logo_generator_image = Task(
        name="Logo Generation",
        agent=graphic_designer,
        output_type=OutputType.IMAGE,
        input_type=InputType.TEXT,
        model=open_ai_model_image,
        log_output=True,
        instructions="Generate an Image which is suitable to the given description. Capture every detail. Minimalistic style. [IMPORTANT!] Avoid any text or numbers in the image.",
        default_input=user_specification
    )


    logo_generator_image_innovative = Task(
        name="Logo Generation",
        agent=graphic_designer,
        output_type=OutputType.IMAGE,
        input_type=InputType.TEXT,
        model=open_ai_model_image,
        log_output=True,
        instructions="Generate a fresh logo concept to the given description. Minimalistic style. [IMPORTANT!] Avoid any text or numbers in the image.",
        default_input=user_specification
    )


    logo_generator_image_dynamic = Task(
        name="Logo Generation",
        agent=graphic_designer,
        output_type=OutputType.IMAGE,
        input_type=InputType.TEXT,
        model=open_ai_model_image,
        log_output=True,
        instructions="Generate a dynamic logo to the given description. Minimalistic style. [IMPORTANT!] Avoid any text or numbers in the image.",
        default_input=user_specification
    )


    logo_generator_image_luxury = Task(
        name="Logo Generation",
        agent=graphic_designer,
        output_type=OutputType.IMAGE,
        input_type=InputType.TEXT,
        model=open_ai_model_image,
        log_output=True,
        instructions="Generate a luxury standout logo to the given description. Minimalistic style. [IMPORTANT!] Avoid any text or numbers in the image.",
        default_input=user_specification
    )


    logger = Logger()


    main_output = LinearSyncPipeline(
        logger=logger,
        name="Logo Generator",
        completion_message="App Generated logo's!",
        tasks=[
            logo_generator_image,
            logo_generator_image_innovative,
            logo_generator_image_dynamic,
            logo_generator_image_luxury
        ],
    ).run()


    return main_output

Initializing the Application

The entry point of the Logo Generator application prompts the user to input details about their business and the desired logo. Upon clicking the submit button, the logo_generator function is invoked with the user's input as the specification for logo generation. The generated logos are then displayed in a visually appealing manner.

if __name__ == "__main__":
    user_input = st.text_area("What kind of Business do you have?, Write about logo!")

    button=st.button('Submit')
    if (button==True):
        generated_output = logo_generator(user_specification=user_input)

        col1, col2 = st.columns(2)

        with col1:
            image_file_name = generated_output[0]['task_output'].local_file_path
            st.subheader("Logo")
            st.image(image_file_name, caption='Logo Generator - Lyzr')
            st.markdown('---')

            st.subheader('Innovative Logo')
            second_image_file_name = generated_output[1]['task_output'].local_file_path
            st.image(second_image_file_name, caption='Logo Generator - Lyzr')
            st.markdown('---')

        with col2:
            st.subheader('Dynamic Logo')
            fourth_image_file_name = generated_output[2]['task_output'].local_file_path
            st.image(fourth_image_file_name, caption='Logo Generator - Lyzr')
            st.markdown('---')

            st.subheader('Luxury Logo')
            fifth_image_file_name = generated_output[3]['task_output'].local_file_path
            st.image(fifth_image_file_name, caption='Logo Generator - Lyzr')
            st.markdown('---')

Conclusion

Lyzr's Logo Generator, businesses and individuals can effortlessly create visually stunning and versatile logos that leave a lasting impression. Embrace the power of artificial intelligence to craft logos that effectively represent your brand's identity and values.

References

Gain a Competitive Edge with Lyzr's Analyze Competitor Content App

Prajjwal Sule — Thu, 04 Apr 2024 17:49:02 +0000

In today’s dynamic digital landscape, understanding your competitors and devising a robust content strategy are paramount to success. Enter the Analyze Competitor Content app by Lyzr, an innovative tool that harnesses the power of AI to provide actionable insights into competitors’ content strategies. In this article, we’ll explore how this cutting-edge tool revolutionizes content strategy and empowers brands to differentiate themselves in the market.

Welcome to Lyzr! | Lyzr Documentation

Explore the limitless possibilities of Generative AI with Lyzr, an enterprise alternative to popular Generative AI SaaS products. Lyzr offers a robust and secure solution for building and launching your own enterprise-grade Generative AI applications with speed and confidence.

docs.lyzr.ai

Setting up the Project

To get started with Lyzr's Analyze Competitor Content app, follow these steps:

Clone the App: Clone the Analyze Competitor Content app repository from GitHub.

   git clone https://github.com/PrajjwalLyzr/Analyze-Competitor-Content

Create a Virtual Environment: Set up a virtual environment and activate it.

   python3 -m venv venv
   source venv/bin/activate

Set Environment Variables: Create a .env file and add your OpenAI API key.

   OPENAI_API_KEY = "Paste your openai api key here"

Install Dependencies: Install the required dependencies.

   pip install lyzr-automata streamlit python-dotenv

Structure

Analyze-Competitor-Content
│
│
├── app.py
│
├── README.md
│
├── .gitignore
│
└── requirements.txt

Core Components of the Analyze Competitor Content App

Let's explore the key components of Lyzr's Analyze Competitor Content app:

import os
import streamlit as st
from lyzr_automata.ai_models.openai import OpenAIModel
from lyzr_automata import Agent, Task, Logger
from lyzr_automata.tasks.task_literals import InputType, OutputType
from lyzr_automata.pipelines.linear_sync_pipeline import LinearSyncPipeline
from dotenv import load_dotenv

load_dotenv()

API_KEY = os.getenv('OPENAI_API_KEY')

open_ai_model_text = OpenAIModel(
    api_key=API_KEY,
    parameters={
        "model": "gpt-4-turbo-preview",
        "temperature": 0.5,
        "max_tokens": 1500,
    },
)

def analyze_competitor_content(content_title, target_audience):
    content_strategy_analyst = Agent(
        prompt_persona="""You are a Content Strategy Analyst expert who analyzes a list of competitor content titles and devises a comprehensive strategy to differentiate our brand. Your task is to meticulously examine the competitor landscape, identify gaps, and propose 10 unique content topics that showcase our brand's expertise and distinct value proposition. Leveraging your expertise in content analysis, market research, and strategic planning, you'll develop innovative ideas that resonate with our target audience and set us apart from the competition.""",
        role="Content Strategy Analyst",
    )

    contnet_generator =  Task(
        name="Campaign Generator",
        agent=content_strategy_analyst,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
        model=open_ai_model_text,
        instructions=f"Use the description provided, given a list of competitor content titles, analyze and suggest 10 unique content topics that would differentiate our brand, and the Target Audience: {target_audience}. [IMPORTANT!] Setup the events in a detailed manner",
        log_output=True,
        enhance_prompt=False,
        default_input=content_title
    )

    logger = Logger()

    main_output = LinearSyncPipeline(
        logger=logger,
        name="Analyze Competitor Content",
        completion_message="App Generated all things!",
        tasks=[
            contnet_generator,
        ],
    ).run()

    return main_output

Executing the Application

To run Lyzr's Analyze Competitor Content app:

if __name__ == "__main__":
    titles = st.text_area("Write down list of competitor content titles")
    audience = st.text_area('Targeted Audience')

    button=st.button('Submit')
    if (button==True):
        generated_output = analyze_competitor_content(content_title=titles, target_audience=audience)
        title_output = generated_output[0]['task_output']
        st.write(title_output)
        st.markdown('---')

Upon clicking the “Submit” button, the app triggers the analyze_competitor_content function, passing the entered titles and audience description as arguments. The generated output includes ten unique content topics suggested by the Lyzr Automata Agent.

Conclusion

With Lyzr's Analyze Competitor Content app, content strategists can gain invaluable insights into competitors’ content strategies and devise compelling strategies to differentiate their brand. Embrace the power of AI to stay ahead of the competition and captivate your target audience.

References

Analyze Competitor Content GitHub Repository
Lyzr Website
Book a Demo
Lyzr Community Channels: Discord, Slack

Revolutionize Your Writing Process with Lyzr's Book Writing Assistant

Prajjwal Sule — Tue, 02 Apr 2024 05:02:53 +0000

In the realm of literature, the journey from idea to publication can be arduous. Lyzr, a frontrunner in AI-powered solutions, unveils its latest breakthrough: the Book Writing Assistant. This innovative tool is poised to revolutionize the way authors craft their masterpieces, providing indispensable support and inspiration at every step of the writing process.

The Book Writing Assistant by Lyzr is your ultimate AI muse, offering unparalleled assistance in various aspects of book creation, from generating captivating titles to designing stunning book covers. With its intuitive interface and cutting-edge AI models, this tool empowers authors and aspiring writers to unleash their creativity and bring their literary visions to life.

Welcome to Lyzr! | Lyzr Documentation

docs.lyzr.ai

Setting up the Project

Let's dive into setting up the project for Lyzr's Book Writing Assistant

Clone the App: Start by cloning the Book Writing Assistant app repository.

   git clone https://github.com/PrajjwalLyzr/Book-Writing-Assistant

Create a Virtual Environment: Set up a virtual environment and activate it.

   python3 -m venv venv
   source venv/bin/activate

Set Environment Variables: Create a .env file and add your OpenAI API key.

   OPENAI_API_KEY = "Paste your openai api key here"

Install Dependencies: Install the required dependencies.

   pip install lyzr-automata streamlit python-dotenv

Project Structure

Book-Writing-Assistant
│
│
├── app.py
│
├── README.md
│
├── .gitignore
│
└── requirements.txt

Core Components of the Book Writing Assistant

Imports necessary libraries like os, PIL, streamlit, and modules from Lyzr’s automata. It also loads the OpenAI API key from environment variables. The API_KEY is retrieved using os.getenv. This key is crucial for accessing OpenAI’s services.

import os
import streamlit as st
from lyzr_automata.ai_models.openai import OpenAIModel
from lyzr_automata import Agent, Task, Logger
from lyzr_automata.tasks.task_literals import InputType, OutputType
from lyzr_automata.pipelines.linear_sync_pipeline import LinearSyncPipeline
from dotenv import load_dotenv

load_dotenv()

API_KEY = os.getenv('OPENAI_API_KEY')

Setup the OpenAI models for Book Writing Assistant

Initializes two instances of the OpenAIModel class, which facilitate interactions with OpenAI’s models. The first instance, open_ai_model_image, is configured to work with the DALL-E model, designed for image generation tasks. It specifies parameters such as the API key, the number of samples to generate (n), and the model name.

open_ai_model_image = OpenAIModel(
    api_key=API_KEY,
    parameters={
        "n": 1,
        "model": "dall-e-3",
    },
)


open_ai_model_text = OpenAIModel(
    api_key= API_KEY,
    parameters={
        "model": "gpt-4-turbo-preview",
        "temperature": 0.5,
        "max_tokens": 1500,
    },
)

Kernel of Book Writing Assistant Application

Lyzr Automata is a sophisticated multi-agent automation framework designed to keep things simple, with a focus on workflow efficiency and effectiveness. It enables the creation of multiple agents that are coupled with specific tasks.

def book_writing_assistant(genre):

    writer_agent = Agent(
        prompt_persona="You are an expert book writer and a graphic designer, good at writing books on a single keyword as well as making attractive cover pages for your books, you can also provide the chapters regarding the any topic",
        role=" book writer",
    )


    title_generation = Task(
        name="Book Title Creator",
        agent=writer_agent,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
        model=open_ai_model_text,
        instructions="Use the description provided and write some set of titles for the book. Use your creativity. [IMPORTANT!] Setup the events in a detailed manner",
        log_output=True,
        enhance_prompt=False,
        default_input=genre
    )


    chapter_generation = Task(
        name="Book Chapters Creator",
        agent=writer_agent,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
        model=open_ai_model_text,
        instructions="Use the description provided and write some set book chapters and well give the blueprint of how to write the book on the provided description. Use your creativity. [IMPORTANT!] Setup the events in a detailed manner",
        log_output=True,
        enhance_prompt=False,
        default_input=genre
    )


    book_writing_tips =  Task(
        name="Book Writing Tips",
        agent=writer_agent,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
        model=open_ai_model_text,
        instructions="Use the description provided and give the 4-5 bullet points in 20-30 words of book writing tips on the provided description. Use your creativity. [IMPORTANT!] Setup the events in a detailed manner",
        log_output=True,
        enhance_prompt=False,
        default_input=genre
    )



    book_cover_image = Task(
        name="Book Cover Image Creation",
        output_type=OutputType.IMAGE,
        input_type=InputType.TEXT,
        model=open_ai_model_image,
        log_output=True,
        instructions="Generate an Image which is suitable to the given description. Capture every detail. Minimalistic style. [IMPORTANT!] Avoid any text or numbers in the image.",
    )


    logger = Logger()


    main_output = LinearSyncPipeline(
        logger=logger,
        name="Book Writing Assistant",
        completion_message="Book Writing Assistant Generated all things!",
        tasks=[
            title_generation,
            chapter_generation,
            book_writing_tips,
            book_cover_image,
        ],
    ).run()


    return main_output

It comes up with potential titles for the book based on what the writer wants to write about. Makes a plan for what each chapter of the book could be about, helping the writer organize their ideas.

Executing the Application

To run Lyzr's Book Writing Assistant:

if __name__ == "__main__":
    style_app() 
    book_brief = st.text_input("Enter about the book, a title or a genre")
    button=st.button('Submit')
    if (button==True):

        generated_output = book_writing_assistant(book_brief)

        # DISPLAY OUTPUT
        title_output = generated_output[0]['task_output']
        st.header('Suggested Titles')
        st.write(title_output)
        st.markdown('---')

        chapter_output = generated_output[1]['task_output']
        st.header("Suggested Chapter's")
        st.write(chapter_output)
        st.markdown('---')

        writing_tips = generated_output[2]['task_output']
        st.header('Writing Tips')
        st.write(writing_tips)
        st.markdown('---')

        image_file_name = generated_output[3]['task_output'].local_file_path
        st.header('Book Cover Page')
        st.image(image_file_name, caption='Book Writing Assistant - Lyzr')

With Lyzr's Book Writing Assistant, the daunting task of writing a book is transformed into an inspiring and fulfilling journey. Embrace the power of AI to unleash your creativity and bring your literary dreams to fruition.

References

Book Writing Assistant - GitHub Repository
Lyzr Website
Book a Demo
Lyzr Community Channels: Discord, Slack

Simplify Instagram Content Creation with Caption Studio by Lyzr.ai

Prajjwal Sule — Tue, 02 Apr 2024 04:32:12 +0000

In the digital age, Instagram has emerged as a powerful platform for individuals and businesses alike to connect with their audience. However, creating engaging content can be a daunting task. Enter Caption Studio by Lyzr.ai, an AI-powered tool designed to streamline the process of generating creative captions and images for Instagram posts.

In this article, we'll explore how Caption Studio simplifies content creation for Instagram, making it easier for users to craft catchy captions and eye-catching images.

Welcome to Lyzr! | Lyzr Documentation

docs.lyzr.ai

Setting up the Project

Let's start by setting up the project for Caption Studio:

Clone the Caption Studio app repository

   git clone https://github.com/PrajjwalLyzr/Caption-Studio

Create a virtual environment and activate it

   python3 -m venv venv
   source venv/bin/activate

Create a .env file and add your OpenAI API key

   OPENAI_API_KEY = "Paste your openai api key here"

Install the required dependencies

   pip install lyzr-automata streamlit python-dotenv

Project Structure

The project structure consists of the following files:

Caption-Studio
│
│
├── app.py
│
├── README.md
│
├── .gitignore
│
└── requirements.txt

An entry point for an application ‘app.py’

import os
from PIL import Image
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 lyzr_automata.pipelines.linear_sync_pipeline  import  LinearSyncPipeline
from lyzr_automata import Logger
from dotenv import load_dotenv; load_dotenv()


API_KEY = os.getenv('OPENAI_API_KEY')

Setup the OpenAI models for Caption Studio

Initializes two instances of the OpenAIModel class, which facilitates interactions with OpenAI’s models. The first instance, open_ai_model_image, is configured to work with the DALL-E model, designed for image generation tasks. It specifies parameters such as the API key, the number of samples to generate (n), and the model name.

open_ai_model_image = OpenAIModel(
    api_key=API_KEY,
    parameters={
        "n": 1,
        "model": "dall-e-3",
    },
)



open_ai_model_text = OpenAIModel(
    api_key= API_KEY,
    parameters={
        "model": "gpt-4-turbo-preview",
        "temperature": 0.5,
        "max_tokens": 1500,
    },
)

Kernel of Caption Studio Application


def ig_caption_studio(input_content):
    social_media_manager_agent = Agent(
        prompt_persona="You are an expert social media manager good at writing a short and catchy instagram captions, as well creating the intagram images",
        role="social media manager",
    )

    instagram_caption_task = Task(
        name="Instagram Caption Creator",
        agent=social_media_manager_agent,
        output_type=OutputType.TEXT,
        input_type=InputType.TEXT,
        model=open_ai_model_text,
        instructions="Use the description provided and write some set of catchy 5-7 Instagram captions in 20-30 words. Use your creativity. [IMPORTANT!] Setup the events in a detailed manner",
        log_output=True,
        enhance_prompt=False,
        default_input=input_content
    )

    instagram_image_task = Task(
        name="Instagram Image Creation",
        output_type=OutputType.IMAGE,
        input_type=InputType.TEXT,
        model=open_ai_model_image,
        log_output=True,
        instructions="Generate an Instagram image for the given description. Capture every detail. Minimalistic style. [IMPORTANT!] Avoid any text or numbers in the image.",
    )

    logger = Logger()

    main_output = LinearSyncPipeline(
        logger=logger,
        name="Caption Generator",
        completion_message="IG Caption and Image Generated!",
        tasks=[
            instagram_caption_task,
            instagram_image_task,
        ],
    ).run()

    return main_output

Executing the Application

To run the Caption Studio application:

if __name__ == "__main__":
    caption_brief = st.text_area("Enter about caption")
    button = st.button('Submit')
    if button:
        generated_output = ig_caption_studio(caption_brief)
        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='Caption Studio')

Caption Studio by Lyzr.ai revolutionizes Instagram content creation, making it easier and more efficient. With AI-powered tools like Caption Studio, users can create captivating captions and images with ease.

References

Caption Studio GitHub Repository: GitHub
Lyzr Website: https://www.lyzr.ai/
Book a Demo: https://www.lyzr.ai/book-demo/
Lyzr Community Channels: Discord, Slack

Building a Social Media Advisor with Lyzr's RAG and VoiceBot Agent

Prajjwal Sule — Thu, 28 Mar 2024 19:11:55 +0000

In today's digital landscape, social media plays a crucial role in reaching and engaging with audiences. However, creating compelling content tailored for different platforms can be challenging. In this article, we'll explore how to leverage Lyzr's RAG (Retrieval-Augmented Generation) and VoiceBot Agent to streamline the process of generating social media content.

Introduction

In the fast-paced world of social media, creating engaging content that resonates with your audience is paramount. Lyzr's Social Media Advisor simplifies the content creation process by leveraging advanced technologies such as ChatBot and VoiceBot.

Lyzr Open Source SDKs 🚀 | Lyzr Documentation

Welcome to the Lyzr Open Source Software Development Kit (SDK)!

docs.lyzr.ai

Setting up the Project

Let's dive into the steps required to set up the Social Media Advisor project:

Clone the app:

   python3 -m venv venv
   source venv/bin/activate

Create an environment variable:
Create a .env file and add your OpenAI API key:

   OPENAI_API_KEY = "Paste your openai api key here"

Install the required dependencies:

   pip install lyzr streamlit docx2txt

Project Structure

The project structure consists of several directories and files:

Social-Media-Advisor
│
├── utils/
│   ├── __init__.py
│   └── utils.py
│
├── app.py
│
├── README.md
│
└── .gitignore

Utilizing Common Functions

Let's explore the common utility functions defined in utils.py

`get_files_in_directory()`

import os
import shutil
import streamlit as st
from dotenv import load_dotenv; load_dotenv()
from openai import OpenAI


API_KEY = os.getenv('OPENAI_API_KEY')


def remove_existing_files(directory):
    for filename in os.listdir(directory):
        file_path = os.path.join(directory, filename)
        try:
            if os.path.isfile(file_path) or os.path.islink(file_path):
                os.unlink(file_path)
            elif os.path.isdir(file_path):
                shutil.rmtree(file_path)
        except Exception as e:
            st.error(f"Error while removing existing files: {e}")

`get_files_in_directory()`

def get_files_in_directory(directory):
    files_list = []

    if os.path.exists(directory) and os.path.isdir(directory):
        for filename in os.listdir(directory):
            file_path = os.path.join(directory, filename)

            if os.path.isfile(file_path):
                files_list.append(file_path)


    return files_list

`save_uploaded_file()`

def save_uploaded_file(directory, uploaded_file):
    remove_existing_files(directory=directory)
    file_path = os.path.join(directory, uploaded_file.name)
    with open(file_path, "wb") as file:
        file.write(uploaded_file.read())
    st.success("File uploaded successfully")

`file_checker()`

def file_checker():
    file = []
    for filename in os.listdir('data'):
        file_path = os.path.join('data', filename)
        file.append(file_path)

    return file

Implementing Core Functionalities

Generating Social Media Content

def social_media(agent):
    content = {}
    prompts = {'LinkedIn': """
                        Craft an engaging LinkedIn post based on this article.
                        Share a concise yet compelling overview of article's key points to capture the audience's attention.
                        Remember to include relevant hashtags and a call-to-action to encourage further engagement and drive traffic to your article. Let's create an impactful post that resonates with your LinkedIn network!
            """,


            "Twitter":"""
                        Craft a captivating tweet inspired by the essence of this article.
                        Condense the key insights into 1-2 punchy lines that grab attention and leave readers intrigued.
                        Ensure the tweet is concise yet impactful, and don't forget to add relevant hashtags to expand your reach. Let's compose a tweet that sparks curiosity and drives engagement!


            """,




            "Facebook":"""
                        Compose an engaging Facebook post that encapsulates the essence of this article.
                        Share a brief summary that highlights the most compelling aspects, aiming to captivate your audience's interest.
                        Consider adding an eye-catching image or video to enhance the post's appeal, and encourage interaction by asking a thought-provoking question or inviting comments. Let's craft a post that resonates with your Facebook followers and sparks meaningful conversations!


            """}


    for platfrom, prompt in prompts.items():
        response = agent.chat(prompt)
        content[platfrom] = response.response


    return content

Generating Content Summaries

def prompts(agent):
    results = {}
    prompt = {'Voice_Ad':'create an article summary for advertisement in 150-200 words',
               'Instagram_post':'create an article summary for Instagram post in 10-20 words.' }  


    for platfrom, prompt in prompt.items():        
        response = agent.chat(prompt)
        results[platfrom] = response.response


    return results

Displaying Responses

def get_response(response:dict):
    for platfrom, response in response.items():
        st.subheader(platfrom)
        st.write(response)
        st.markdown("---")

Generating Instagram Images

def instagram_img(prompt):
    client = OpenAI(api_key=API_KEY)
    response = client.images.generate(
    model="dall-e-3",
    prompt=prompt,
    size="1024x1024",
    quality="standard",
    n=1,
    )

An entry point for an application ‘app.py’

Functions defined in app.py

import os
from PIL import Image
from utils import utils
import streamlit as st
from dotenv import load_dotenv; load_dotenv()
from lyzr import VoiceBot, ChatBot


# Social Media Advisor Application
data = 'data'
audio_directory = 'audio'
os.makedirs(data, exist_ok=True)
os.makedirs(audio_directory, exist_ok=True)
original_directory = os.getcwd()


# replace this with your openai api key or create an environment variable for storing the key.
API_KEY = os.getenv('OPENAI_API_KEY')

def qabot_agent():
    path = utils.get_files_in_directory(data)
    qa_agent = ChatBot.docx_chat(
        input_files=path
    )

    return qa_agent



def voicebot_agent(add_summary):
    vb = VoiceBot(api_key=API_KEY)
    try:
        os.chdir(audio_directory)
        vb.text_to_speech(add_summary)
    finally:
        os.chdir(original_directory)

Initializing Social Media Advisor application

if __name__ == "__main__":
    article = st.file_uploader('Upload your article documet',type=["docx"])
    if article:
        utils.save_uploaded_file(directory=data, uploaded_file=article)
        file = utils.file_checker()
        if len(file)>0:
            if st.button('Create'):
                agent = qabot_agent()
                response = utils.social_media(agent=agent)
                results = utils.prompts(agent=agent)
                if response:
                    utils.get_response(response=response)
                    if results:
                        voicebot_agent(add_summary=results['Voice_Ad'])
                        st.subheader('Voice Advertisment')
                        files = utils.get_files_in_directory(audio_directory)
                        audio_file = files[0]
                        st.audio(audio_file)  
                        st.markdown('---')
                        st.subheader('Instagram')
                        insta_img_prompt = results['Instagram_post'] + " " + "Avoid any text or numbers in the image"
                        insta_image = utils.instagram_img(insta_img_prompt)
                        st.image(insta_image, caption='Instagram Image', use_column_width=True)


    else:
        utils.remove_existing_files(data)
        st.warning('Please Upload article document file')

Conclusion

In this article, we've explored how to build a Social Media Advisor application using Lyzr's RAG and VoiceBot Agent. By leveraging these technologies, content creators can streamline the process of generating engaging social media content tailored for different platforms.

References

For further exploration and engagement, refer to Lyzr’s website, book a demo, or join the community channels on Discord and Slack.

Social Media Advisor: GitHub

Lyzr Website: https://www.lyzr.ai/

Book a Demo: https://www.lyzr.ai/book-demo/

Lyzr Community Channels: Discord, Slack

Building GenAI Application for Interactive Audiobooks using Lyzr’s VoiceBot Agent

Prajjwal Sule — Wed, 27 Mar 2024 18:47:36 +0000

In today's fast-paced digital world, storytelling has evolved beyond traditional mediums. With the emergence of innovative technologies, the way we experience narratives is undergoing a transformative shift. In this article, we'll explore how Lyzr's Interactive Audiobook is revolutionizing storytelling by seamlessly blending cutting-edge technology with the timeless art of storytelling.

Interactive Audiobooks with Lyzr’s VoiceBot Agent

Interactive storytelling represents a paradigm shift in the way we engage with narratives. Gone are the days of passive consumption; instead, audiences crave immersive experiences that allow them to actively participate in the story's evolution. VoiceBot, a versatile agent by Lyzr, utilizes OpenAI's powerful APIs to perform text-to-speech conversion, audio transcription, and text summarization into structured notes.

Lyzr’s Approach to Application Development

Lyzr offers an agent-centric approach to rapidly developing LLM (Large Language Model) applications with minimal code and time investment. Even if you're unfamiliar with the GenAI stack, Lyzr empowers you to build your AI applications effortlessly. It is the go-to solution for constructing GenAI apps without requiring an in-depth understanding of Generative AI.

Lyzr Open Source SDKs 🚀 | Lyzr Documentation

Welcome to the Lyzr Open Source Software Development Kit (SDK)!

docs.lyzr.ai

Setting up the Project

Clone the "Interactive Audiobook" app repository.
Set up a virtual environment

python3 -m venv venv
source venv/bin/activate

Create an environment file named .env and add your OpenAI API key

OPENAI_API_KEY = “Your_OpenAI_API_Key”

Install the required dependencies

pip install lyzr streamlit

Project Structure

The project includes directories for utilities, the main application file, a README, environment variables, and a Git ignore file.

Interactive-Audiobook
│
├── utils/
│   ├── __init__.py
│   └── utils.py
│
│
├── app.py
│
├── README.md
│
├── .env
│
├── .gitignore
│
└── requirements.txt

Utility Functions

The utils.py file contains essential utility functions for the application, such as get_files_in_directory to retrieve file paths within a directory and prompt to generate specific prompts for creating children's stories.

import os
from dotenv import load_dotenv; load_dotenv()
from openai import OpenAI



def get_files_in_directory(directory):
    # This function help us to get the file path along with filename.
    files_list = []

    if os.path.exists(directory) and os.path.isdir(directory):
        for filename in os.listdir(directory):
            file_path = os.path.join(directory, filename)

            if os.path.isfile(file_path):
                files_list.append(file_path)

    return files_list


def prompt(user_input):
    prompt = f"""You are an expert to create kid's stories, create a complete story on this {user_input}. 
    Make sure story obeys these points: 
     1. Story should be short and precise.
     2. Story will cover from introduction to climax in 500-700 words. 
     3. Story will proivde valuable learning's for children's.
    """

    return prompt


def story_generator(prompt):
    API_KEY = os.getenv('OPENAI_API_KEY')
    ai = OpenAI(api_key=API_KEY)

    response = ai.completions.create(
        model="gpt-3.5-turbo-instruct",
        prompt=prompt,
        temperature=0.1,
        max_tokens=1000)

    story = response.choices[0].text.strip()
    return story

The story_generator function you provided is responsible for generating a story based on a given prompt using the OpenAI GPT-3.5 model.

Creating an Entry Point for the Application ‘app.py’

The entry point script initializes the application, sets up the environment, and defines the location of the OpenAI API key.

import os
from PIL import Image
from utils import utils
from pathlib import Path
import streamlit as st
from dotenv import load_dotenv; load_dotenv()
from lyzr import VoiceBot


# Interactive Audiobook Application


audio_directory = 'audio'
os.makedirs(audio_directory, exist_ok=True)
original_directory = os.getcwd()

# replace this with your openai api key or create an environment variable for storing the key.
API_KEY = os.getenv('OPENAI_API_KEY')

Interactive Audiobook by VoiceBot Agent

This core component generates interactive audiobooks. It takes a user story as input, converts it into an audio file using Lyzr's VoiceBot Agent, and stores the audio file in the designated directory.

def audiobook_agent(user_story:str):
    vb = VoiceBot(api_key=API_KEY)
    try:
        os.chdir(audio_directory)
        vb.text_to_speech(user_story)
    finally:
        os.chdir(original_directory)

Implementing an Entry Point for the Application

The main execution point prompts the user to input a brief about the story, generates a story based on the prompt, displays a shortened version of the story, converts it into an audiobook, and presents it as an audio player. If the user fails to provide input, a warning message prompts them to do so.

if __name__ == "__main__":
    topic = st.text_input('Write breif about the story')
    if st.button('Create'):
        if topic:
            prompt = utils.prompt(user_input=topic)
            story = utils.story_generator(prompt=prompt)
            st.subheader('Glimpse of Story')
            shorten_story = story[:450]
            st.write(shorten_story)
            st.markdown('---')
            st.subheader('Story into audiobook')
            audiobook_agent(user_story=story)
            files = utils.get_files_in_directory(audio_directory)
            audio_file = files[0]
            st.audio(audio_file)            
        else:
            st.warning("Provide the content for story, don't keep it blank")

Interactive Audiobooks powered by Lyzr’s VoiceBot Agent offer an immersive and engaging storytelling experience. By leveraging advanced technologies, this application enables users to create dynamic narratives and captivate audiences in new and innovative ways.

References

For further exploration and engagement, visit Lyzr’s website, book a demo, or join the community channels on Discord and Slack.

This article provides a comprehensive guide for building interactive audiobooks using Lyzr’s VoiceBot Agent, highlighting its role in transforming traditional storytelling into immersive experiences.

DEV Community: Prajjwal Sule

Transform Your Text with Lyzr.ai: A Step-by-Step Guide

Simplify Restaurant Reservations with Lyzr.ai's Chatbot-Powered App

Introducing the Restaurant-Reservations App

Setting up the Project

Utils Module for Common Functions

Entry Point for the Application (app.py)

Executing the Restaurant-Reservations Application

References

Elevate Your Interview Preparation with the AI Interviewer App

Setting up the Project

Core Components of the AI Interviewer App

Utils Module for Common Functions

Interface for Large Language Model (LLM) Calling

Kernel for the AI Interviewer Application

Entry Point for the Application (app.py)

Executing the Application

Conclusion

References

Revolutionize Education with Lyzr's Question-Answer Generator

Lyzr

Setting up the Project

Core Components of the Question-Answer Generator App

Utils Module for Common Functions

Interface for Large Language Model (LLM) Calling

Kernel for Question Answer Generator Application

Entry Point for the Application (app.py)

Executing the Application

References

Revolutionize Your Podcast Content Creation with Lyzr's Podcast Series Generator

Setting up the Project

Core Components of the Podcast Series Generator App

Initializing the Application

Conclusion

References

Elevate Your Content Strategy with Lyzr's Content Campaign Generator

Setting up the Project

Core Components of the Content Campaign Generator App

Initializing the Application

Conclusion

References

Design Memorable Logos with Lyzr's Logo Generator

Setting up the Project

Structure

Core Components of the Logo Generator App

Initializing the Application

Conclusion

References

Gain a Competitive Edge with Lyzr's Analyze Competitor Content App

Setting up the Project

Structure

Core Components of the Analyze Competitor Content App

Executing the Application

Conclusion

References

Revolutionize Your Writing Process with Lyzr's Book Writing Assistant

Setting up the Project

Project Structure

Core Components of the Book Writing Assistant

Setup the OpenAI models for Book Writing Assistant

Kernel of Book Writing Assistant Application

Executing the Application

References

Simplify Instagram Content Creation with Caption Studio by Lyzr.ai

Setting up the Project

Project Structure

An entry point for an application ‘app.py’

Setup the OpenAI models for Caption Studio

Kernel of Caption Studio Application

Executing the Application

References

Building a Social Media Advisor with Lyzr's RAG and VoiceBot Agent

Introduction

Lyzr Open Source SDKs 🚀 | Lyzr Documentation Welcome to the Lyzr Open Source Software Development Kit (SDK)! docs.lyzr.ai

Setting up the Project

Project Structure

Utilizing Common Functions

get_files_in_directory()

get_files_in_directory()

save_uploaded_file()

Entry Point for the Application (`app.py`)

Entry Point for the Application (`app.py`)

Entry Point for the Application (`app.py`)

Lyzr Open Source SDKs 🚀 | Lyzr Documentation

Welcome to the Lyzr Open Source Software Development Kit (SDK)!

docs.lyzr.ai

`get_files_in_directory()`

`get_files_in_directory()`

`save_uploaded_file()`

`file_checker()`

Lyzr Open Source SDKs 🚀 | Lyzr Documentation

Welcome to the Lyzr Open Source Software Development Kit (SDK)!

docs.lyzr.ai