I like writing. It’s possible you’ll discover that if you happen to observe me or my weblog. For that cause, I’m continuously producing new content material and speaking about Knowledge Science and Synthetic Intelligence.
I found this ardour a few years in the past after I was simply beginning my path in Knowledge Science, studying and evolving my abilities. At the moment, I heard some extra skilled professionals within the space saying {that a} good research method was training new abilities and writing about it someplace, educating no matter you realized.
As well as, I had simply moved to the US, and no one knew me right here. So I needed to begin someplace, creating my skilled picture on this aggressive market. I bear in mind I talked to my cousin, who’s additionally within the Tech business, and he informed me: write weblog posts about your experiences. Inform folks what you’re doing. And so I did.
And I by no means stopped.
Quick ahead to 2025, now I’ve virtually 200 revealed articles, lots of them with In direction of Knowledge Science, a broadcast Guide, and an excellent viewers.
Writing helped me a lot within the Knowledge Science space.
Most just lately, certainly one of my pursuits has been the wonderful Pure Language Processing and Massive Language Fashions topics. Studying about how these trendy fashions work is fascinating.
That curiosity led me to experiment with Agentic Ai as properly. So, I realized about CrewAI, a simple and open-source package deal that helps us construct AI brokers in a enjoyable and simple approach, with little code. I made a decision to check it by making a crew of brokers to jot down a weblog submit, after which see how that goes.
On this submit, we are going to learn to create these brokers and make them work collectively to provide a easy weblog submit.
Let’s do this.
What’s a Crew?
A crew of AI brokers is a mixture of two or extra brokers, every of them performing a activity in direction of a closing objective.
On this case research, we are going to create a crew that may work collectively to provide a small weblog submit a couple of given subject that we are going to present.
The movement works like this:
- We select a given subject for the brokers to jot down about.
- As soon as the crew is began, it should go to the data base, learn a few of my beforehand written articles, and attempt to mimic my writing fashion. Then, it generates a set of tips and passes it to the subsequent agent.
- Subsequent, the Planner agent takes over and searches the Web in search of good content material concerning the subject. It creates a plan of content material and sends it to the subsequent agent.
- The Author agent receives the writing plan and executes it in response to the context and knowledge acquired.
- Lastly, the content material is handed to the final agent, the Editor, who opinions the content material and returns the ultimate doc because the output.
Within the following part, we are going to see how this may be created.
Code
CrewAI is a good Python package deal as a result of it simplifies the code for us. So, let’s start by putting in the 2 wanted packages.
pip set up crewai crewai-tools
Subsequent, if you would like, you may observe the directions on their Quickstart web page and have a full mission construction created for you with simply a few instructions on a terminal. Mainly, it should set up some dependencies, generate the folder construction advised for CrewAI tasks, in addition to generate some .yaml and .py information.
I personally favor to create these myself, however it’s as much as you. The web page is listed within the References part.
Folder Construction
So, right here we go.
We’ll create these folders:
And these information:
- Within the config folder: create the information
brokers.yamlandduties.yaml - Within the data folder, that’s the place I’ll add the information with my writing fashion.
- Within the mission root: create
crew.pyandforemost.py.
Ensure to create the folders with the names talked about, as CrewAI seems for brokers and duties contained in the config folder and for the data base inside a data folder.
Subsequent, allow us to set our brokers.
Brokers
The brokers are composed of:
- Title of the agent:
writer_style - Function: LLMs are good position gamers, so right here you may inform them which position to play.
- Objective: inform the mannequin what the objective of that agent is.
- Backstory: Describe the story behind this agent, who it’s, what it does.
writer_style:
position: >
Writing Fashion Analyst
objective: >
Totally learn the data base and study the traits of the crew,
akin to tone, fashion, vocabulary, temper, and grammar.
backstory: >
You're an skilled ghost author who can mimic any writing fashion.
You know the way to determine the tone and elegance of the unique author and mimic
their writing fashion.
Your work is the premise for the Content material Author to jot down an article on this subject.I gained’t bore you with all of the brokers created for this crew. I imagine you bought the concept. It’s a set of prompts explaining to every agent what they’re going to do. All of the brokers directions are saved within the brokers.yaml file.
Consider it as if you happen to have been a supervisor hiring folks to create a crew. Take into consideration what sorts of execs you would wish, and what abilities are wanted.
We’d like 4 professionals who will work in direction of the ultimate objective of manufacturing written content material: (1) a Author Stylist, (2) a Planner, (3) a Author, and (4) an Editor.
If you wish to see the setup for them, simply test the total code within the GitHub repository.
Duties
Now, again to the analogy of the supervisor hiring folks, as soon as we “employed” our whole crew, it’s time to separate the duties. We all know that we wish to produce a weblog submit, we’ve got 4 brokers, however what every of them will do.
Nicely, that will likely be configured within the file duties.yaml.
As an example, let me present you the code for the Author agent. As soon as once more, these are the elements wanted for the immediate:
- Title of the duty:
write - Description: The outline is like telling the skilled the way you need that activity to be carried out, identical to we might inform a brand new rent easy methods to carry out their new job. Give exact directions to get the very best consequence doable.
- Anticipated output: That is how we wish to see the output. Discover that I give directions like the dimensions of the weblog submit, the amount of paragraphs, and different info that helps my agent to present me the anticipated output.
- Agent to carry out it: Right here, we’re indicating the agent who will carry out this activity, utilizing the identical identify set within the
brokers.yamlfile. - Output file: Now at all times relevant, but when so, that is the argument to make use of. We requested for a markdown file as output.
write:
description: >
1. Use the content material plan to craft a compelling weblog submit on {subject}.
2. Incorporate search engine optimization key phrases naturally.
3. Sections/Subtitles are correctly named in a fascinating method. Ensure
so as to add Introduction, Downside Assertion, Code, Earlier than You Go, References.
4. Add a summarizing conclusion - That is the "Earlier than You Go" part.
5. Proofread for grammatical errors and alignment with the author's fashion.
6. Use analogies to make the article extra partaking and complicated ideas simpler
to know.
expected_output: >
A well-written weblog submit in markdown format, prepared for publication.
The article have to be inside a 7 to 12 minutes learn.
Every part will need to have at the very least 3 paragraphs.
When writing code, you'll write a snippet of code and clarify what it does.
Watch out to not add an enormous snippet at a time. Break it in affordable chunks.
Within the examples, create a pattern dataset for the code.
Within the Earlier than You Go part, you'll write a conclusion that's partaking
and factually correct.
agent: content_writer
output_file: blog_post.mdAfter the brokers and duties are outlined, it’s time to create our crew movement.
Coding the Crew
Now we are going to create the file crew.py, the place we are going to translate the beforehand offered movement to Python code.
We start by importing the wanted modules.
#Imports
import os
from crewai import Agent, Job, Course of, Crew, LLM
from crewai.mission import CrewBase, agent, crew, activity
from crewai.data.supply.pdf_knowledge_source import PDFKnowledgeSource
from crewai_tools import SerperDevToolWe’ll use the essential Agent, Job, Crew, Course of and LLM to create our movement. PDFKnowledgeSource will assist the primary agent studying my writing fashion, and SerperDevTool is the instrument to go looking the web. For that one, be sure to get your API key at https://serper.dev/signup.
A greatest observe in software program growth is to maintain your API keys and configuration settings separate out of your code. We’ll use a .env file for this, offering a safe place to retailer these values. Right here’s the command to load them into the environment.
from dotenv import load_dotenv
load_dotenv()Then, we are going to use the PDFKnowledgeSource to indicate the Crew the place to seek for the author’s fashion. By default, that instrument seems on the data folder of your mission, thus the significance of the identify being the identical.
# Information sources
pdfs = PDFKnowledgeSource(
file_paths=['article1.pdf',
'article2.pdf',
'article3.pdf'
]
)Now we are able to arrange the LLM we wish to use for the Crew. It may be any of them. I examined a bunch of them, and people I appreciated probably the most have been qwen-qwq-32b and gpt-4o. When you select OpenAI’s, you have to an API Key as properly. For Qwen-QWQ, simply uncomment the code and remark out the OpenAI’s strains.. You want an API key from Groq.
# LLMs
llm = LLM(
# mannequin="groq/qwen-qwq-32b",
# api_key= os.environ.get("GROQ_API_KEY"),
mannequin= "gpt-4o",
api_key= os.environ.get("OPENAI_API_KEY"),
temperature=0.4
)Now we’ve got to create a Crew Base, displaying the place CrewAI can discover the brokers and duties configuration information.
# Creating the crew: base exhibits the place the brokers and duties are outlined
@CrewBase
class BlogWriter():
"""Crew to jot down a weblog submit"""
agents_config = "config/brokers.yaml"
tasks_config = "config/duties.yaml"Brokers Features
And we’re able to create the code for every agent. They’re composed of a decorator @agent to indicate that the next perform is an agent. We then use the category Agent and point out the identify of the agent within the config file, the extent of verbosity, being 1 low, 2 excessive. You too can use a Boolean worth, akin to true or false.
Lastly, we specify if the agent makes use of any instrument, and what mannequin it should use.
# Configuring the brokers
@agent
def writer_style(self) -> Agent:
return Agent(
config=self.agents_config['writer_style'],
verbose=1,
knowledge_sources=[pdfs]
)
@agent
def planner(self) -> Agent:
return Agent(
config=self.agents_config['planner'],
verbose=True,
instruments=[SerperDevTool()],
llm=llm
)
@agent
def content_writer(self) -> Agent:
return Agent(
config=self.agents_config['content_writer'],
verbose=1
)
@agent
def editor(self) -> Agent:
return Agent(
config=self.agents_config['editor'],
verbose=1
)Duties Features
The subsequent step is creating the duties. Equally to the brokers, we are going to create a perform and beautify it with @activity. We use the category Job to inherit CrewAI’s functionalities after which level to the duty for use from our duties.yaml file for use for every activity created. If any output file is predicted, use the output_file argument.
# Configuring the duties
@activity
def fashion(self) -> Job:
return Job(
config=self.tasks_config['mystyle'],
)
@activity
def plan(self) -> Job:
return Job(
config=self.tasks_config['plan'],
)
@activity
def write(self) -> Job:
return Job(
config=self.tasks_config['write'],
output_file='output/blog_post.md' # That is the file that will likely be comprise the ultimate weblog submit.
)
@activity
def edit(self) -> Job:
return Job(
config=self.tasks_config['edit']
)Crew
To connect every thing collectively, we now create a perform and beautify it with the @crew decorator. That perform will line up the brokers and the duties within the order to be carried out, for the reason that course of chosen right here is the only: sequential. In different phrases, every thing runs in sequence, from begin to end.
@crew
def crew(self) -> Crew:
"""Creates the Weblog Put up crew"""
return Crew(
brokers= [self.writer_style(), self.planner(), self.content_writer(), self.editor(), self.illustrator()],
duties= [self.style(), self.plan(), self.write(), self.edit(), self.illustrate()],
course of=Course of.sequential,
verbose=True
)Operating the Crew
Operating the crew may be very easy. We create the foremost.py file and import the Crew Base BlogWriter created. Then we simply use the capabilities crew().kickoff(inputs) to run it, passing a dictionary with the inputs for use to generate the weblog submit.
# Script to run the weblog author mission
# Warning management
import warnings
warnings.filterwarnings('ignore')
from crew import BlogWriter
def write_blog_post(subject: str):
# Instantiate the crew
my_writer = BlogWriter()
# Run
consequence = (my_writer
.crew()
.kickoff(inputs = {
'subject': subject
})
)
return consequence
if __name__ == "__main__":
write_blog_post("Value Optimization with Python")There it’s. The result’s a pleasant weblog submit created by the LLM. See beneath.
That’s so good!
Earlier than You Go
Earlier than you go, know that this weblog submit was 100% created by me. This crew I created was an experiment I wished to do to study extra about easy methods to create AI brokers and make them work collectively. And, like I mentioned, I like writing, so that is one thing I’d have the ability to learn and assess the standard.
My opinion is that this crew nonetheless didn’t do an excellent job. They have been in a position to full the duties efficiently, however they gave me a really shallow submit and code. I’d not publish this, however at the very least it could possibly be a begin, perhaps.
From right here, I encourage you to study extra about CrewAI. I took their free course the place João de Moura, the creator of the package deal, exhibits us easy methods to create totally different sorts of crews. It’s actually fascinating.
GitHub Repository
https://github.com/gurezende/Crew_Writer
About Me
If you wish to study extra about my work, or observe my weblog (it’s actually me!), listed below are my contacts and portfolio.
References
[Quickstart CrewAI](https://docs.crewai.com/quickstart)
[CrewAI Documentation](https://docs.crewai.com/introduction)
[GROQ](https://groq.com/)
[OpenAI](https://openai.com)
[CrewAI Free Course](https://study.crewai.com/)
