Social media presence is crucial for businesses and individuals alike. However, consistently creating engaging content can be time-consuming. That’s where automation comes in handy. In this blog post, we’ll explore how to automate tweet generation and posting using the Lyzr Automata.
How It Works
- Topic Input: Users enter a topic of their choice into the Lyzr Tweet Blaster interface.
- Tweet Generation: The application generates tweet ideas based on the provided topic using OpenAI’s GPT-4 model. It presents the user with a selection of generated tweets to choose from.
- Tweet Posting: Once the user selects a tweet, the application further refines it and ensures it meets specific criteria, such as engagement potential and character limit. Finally, it automatically posts the tweet to the user’s Twitter account.
Example Usage
Let’s say you want to tweet about “Artificial Intelligence.” You input the topic into the Lyzr Tweet Blaster and click the “Get Tweets” button. The application generates several tweet ideas related to AI. After selecting the most compelling one, the application refines it and posts it to your Twitter account — all in a matter of seconds!
Setting Up the Environment
Before diving into the details, let’s set up our environment. The Lyzr Tweet Blaster is built using Python and utilizes several libraries, including Streamlit for the user interface, OpenAI for text generation, and the tweet_tool
module for posting tweets. Additionally, we use the dotenv
module for managing API keys securely.
Imports:
pip install lyzr_automata dotenv streamlit tweepy pydantic
tweet.py
from pydantic import BaseModel
from typing import Optional
import tweepy
import os
from dotenv import load_dotenv
load_dotenv()
def post_tweet(tweet):
client = tweepy.Client(consumer_key=os.getenv("CONSUMER_KEY"),
consumer_secret=os.getenv("CONSUMER_SECRET"),
access_token=os.getenv("ACCESS_KEY"),
access_token_secret=os.getenv("ACCESS_SECRET_KEY"))
client.create_tweet(text=tweet)
class TweetInput(BaseModel):
tweet: str
class TweetOutput(BaseModel):
success: bool
message: Optional[str]
Imports:
from pydantic import BaseModel
: Imports theBaseModel
class for creating data models.from typing import Optional
: Imports theOptional
type for indicating optional fields.import tweepy
: Imports thetweepy
library for interacting with the Twitter API.import os
: Imports theos
module for interacting with the operating system.from dotenv import load_dotenv
: Imports theload_dotenv
function to load environment variables from a.env
file
Loading Environment Variables:
load_dotenv()
: This line loads environment variables from a.env
file (likely containing your Twitter API credentials).
post_tweet
Function:
- Takes a single argument
tweet
which is expected to be a string representing the tweet content. - Creates a
tweepy.Client
object using your Twitter API credentials retrieved from environment variables. - Uses the
client.create_tweet
method to post the providedtweet
to your Twitter account.
Data Models:
TweetInput
: Defines a data model for the input data to thepost_tweet
function. It has a single fieldtweet
(required) that represents the tweet content.TweetOutput
: Defines a data model for the output data of thepost_tweet
function (likely not used in this example).
tweet_tool.py
from lyzr_automata.tools.tool_base import Tool
from tweet import TweetOutput,TweetInput,post_tweet
def tweet_posting_tool():
return Tool(
name="LinkedIn Post",
desc="Posts an post on linkedin provided details.",
function=post_tweet,
function_input=TweetInput,
function_output=TweetOutput,
default_params={}
)
Imports:
from lyzr_automata.tools.tool_base import Tool
: Imports theTool
class from thelyzr_automata.tools.tool_base
module. This class is likely used to represent a tool within Lyzr Automata.from tweet import TweetOutput, TweetInput, post_tweet
: Imports theTweetOutput
,TweetInput
data models, and thepost_tweet
function (assumed to be defined elsewhere, likely for posting tweets).
tweet_posting_tool
function:
- This function defines a new tool using the
Tool
class. name
: Sets the name of the tool to "LinkedIn Post" (although it's actually posting tweets).desc
: Provides a description for the tool: "Posts an post on linkedin provided details." (Note: There might be a typo, it should likely be "post" instead of "post on").function
: Specifies the function associated with the tool. Here, it's set to thepost_tweet
function, which is likely responsible for handling the actual tweet posting logic.function_input
: Defines the expected input data model for the tool. Here, it's set toTweetInput
, indicating the tool expects data following theTweetInput
structure (likely containing the tweet content).function_output
: Defines the output data model for the tool. Here, it's set toTweetOutput
, indicating the tool might return data following theTweetOutput
structure (possibly containing success status or error messages).default_params
: Sets any default parameters for the tool (an empty dictionary in this case).
app.py
import streamlit as st
import os
from dotenv import load_dotenv,find_dotenv
from lyzr_automata.ai_models.openai import OpenAIModel
from lyzr_automata import Agent,Task
from lyzr_automata.pipelines.linear_sync_pipeline import LinearSyncPipeline
from PIL import Image
from tweet_tool import tweet_posting_tool
load_dotenv(find_dotenv())
api=os.getenv("OPENAI_API_KEY")
open_ai_text_completion_model = OpenAIModel(
api_key=api,
parameters={
"model": "gpt-4-turbo-preview",
"temperature": 0.2,
"max_tokens": 1500,
},
)
topics = st.text_input("Enter Your Topic")
def tweet_generator(topic):
twitter_agent = Agent(
role="Tweet Expert",
prompt_persona=f"""You are a word class journalist and tweet influencer.
write a viral tweeter thread about given topic using and following below rules:
"""
)
post_tweet = tweet_posting_tool()
generate_topics = Task(
name="Tweet Generator",
model=open_ai_text_completion_model,
instructions=f"""generate 20 topics Regarding {topic} and select 1 best topic from it.
Example:
Input:
genai
20 topics:
Output:
Understanding word embeddings: algorithms, applications, and limitations.
"""
)
generate_tweet = Task(
name="Tweet Generator",
model=open_ai_text_completion_model,
agent=twitter_agent,
input_tasks=[generate_topics],
instructions=f"""write a viral tweeter thread about given topic and following below rules:
1/ The thread is engaging and informative with good data.
2/ Only generate 1 tweet
3/ The thread need to address given topic very well.
4/ The thread needs to be viral and atleast get 1000 likes.
5/ The thread needs to be written in a way that is easy to read and understand.
6/ Output is only threads no any other text apart from thread
7/ The thread character is upto 200 characters not more than it.
Example:
Input:OpenAI
Ouput: OpenAI is reshaping our world with AI innovation, from ChatGPT to DALL·E. Their tech is not just about smarter machines, but about augmenting human creativity and solving complex problems. With a commitment to safety and ethics, OpenAI is leading us into a future where AI empowers everyone. Dive in to see how they're doing it. #OpenAI #Innovation #FutureIsNow 💡🤖✨
"""
)
review_task = Task(
name="Tweet review",
model=open_ai_text_completion_model,
input_tasks=[generate_tweet],
instructions=f"""Your task is to review generated tweet and check whether tweet is upto 200 characters if tweet is more than 200 characters than summarize it in 200 characters.
[!Important]return Improved tweet upto 200 characters.Do not write Improved Tweet.
"""
)
post_task = Task(
name="Tweet Posting",
model=open_ai_text_completion_model,
agent=twitter_agent,
tool=post_tweet,
input_tasks=[review_task]
)
output = LinearSyncPipeline(
name="Tweet Pipline",
completion_message="pipeline completed",
tasks=[
generate_topics,
generate_tweet,
review_task,
post_task
],
).run()
return output[2]['task_output']
if st.button("Get Tweets"):
tweets = tweet_generator(topics)
st.markdown(tweets)
st.success(f"Tweet Uploaded Successfully!!")
Setting Up:
- Imports libraries like Streamlit, OpenAI, and tweet_tool.
- Loads environment variables (likely API keys) securely using
dotenv
. - Creates an OpenAI model object for text generation using GPT-4.
tweet_generator
Function:
- Defines a function named
tweet_generator
that takes the user-provided topic as input. - Creates a “Tweet Expert” Agent within Lyzr Automata.
- Creates a tweet posting tool instance (
post_tweet
). - Defines several Tasks:
- Generate Topics: Uses the OpenAI model to generate 20 topics related to the input topic and selects the best one.
- Generate Tweet: Uses the OpenAI model with the “Tweet Expert” persona to create a viral tweet thread based on the chosen topic, following specific criteria (engaging, informative, under 200 characters).
- Review Tweet: Reviews the generated tweet and ensures it’s within the character limit (200 characters), summarizing if needed.
- Post Tweet: Uses the
post_tweet
tool to post the final tweet. - Creates a LinearSyncPipeline that executes these Tasks sequentially.
Output:
- A button (“Get Tweets”) triggers the
tweet_generator
function with the user's topic. - The generated tweet is displayed using Streamlit markdown (
st.markdown
). - A success message (“Tweet Uploaded Successfully!”) appears upon successful posting (likely using the Twitter API through the
post_tweet
tool).
try it now: https://lyzr-tweet-automation.streamlit.app/
For more information explore the website: Lyzr