Close Menu
    Trending
    • Gemini introducerar funktionen schemalagda åtgärder i Gemini-appen
    • AIFF 2025 Runway’s tredje årliga AI Film Festival
    • AI-agenter kan nu hjälpa läkare fatta bättre beslut inom cancervård
    • Not Everything Needs Automation: 5 Practical AI Agents That Deliver Enterprise Value
    • Prescriptive Modeling Unpacked: A Complete Guide to Intervention With Bayesian Modeling.
    • 5 Crucial Tweaks That Will Make Your Charts Accessible to People with Visual Impairments
    • Why AI Projects Fail | Towards Data Science
    • The Role of Luck in Sports: Can We Measure It?
    ProfitlyAI
    • Home
    • Latest News
    • AI Technology
    • Latest AI Innovations
    • AI Tools & Technologies
    • Artificial Intelligence
    ProfitlyAI
    Home » Creating an AI Agent to Write Blog Posts with CrewAI
    Artificial Intelligence

    Creating an AI Agent to Write Blog Posts with CrewAI

    ProfitlyAIBy ProfitlyAIApril 4, 2025No Comments13 Mins Read
    Share Facebook Twitter Pinterest LinkedIn Tumblr Reddit Telegram Email
    Share
    Facebook Twitter LinkedIn Pinterest Email


    I like writing. It’s possible you’ll discover that should you comply with me or my weblog. For that purpose, I’m continually producing new content material and speaking about Information Science and Synthetic Intelligence.

    I found this ardour a few years in the past after I was simply beginning my path in Information Science, studying and evolving my abilities. At the moment, I heard some extra skilled professionals within the space saying {that a} good examine method was training new abilities and writing about it someplace, educating no matter you discovered.

    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 trade, and he informed me: write weblog posts about your experiences. Inform individuals what you might be doing. And so I did. 

    And I by no means stopped.

    Quick ahead to 2025, now I’ve nearly 2 hundred revealed articles, a lot of them with In direction of Information Science, a printed Ebook, and a great viewers. 

    Writing helped me a lot within the Information Science space.

    Most lately, certainly one of my pursuits has been the superb Pure Language Processing and Giant Language Fashions topics. Studying about how these fashionable fashions work is fascinating. 

    That curiosity led me to experiment with Agentic Ai as effectively. So, I discovered about CrewAI, a simple and open-source bundle that helps us construct AI brokers in a enjoyable and straightforward method, with little code. I made a decision to check it by making a crew of brokers to write down a weblog put up, after which see how that goes.

    On this put up, we’ll learn to create these brokers and make them work collectively to supply a easy weblog put up.

    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 process in direction of a last purpose.

    On this case examine, we’ll create a crew that may work collectively to supply a small weblog put up a couple of given matter that we’ll present.

    Crew of Brokers workflow. Picture by the writer

    The movement works like this:

    1. We select a given matter for the brokers to write down about.
    2. As soon as the crew is began, it can go to the data base, learn a few of my beforehand written articles, and attempt to mimic my writing model. Then, it generates a set of tips and passes it to the following agent.
    3. Subsequent, the Planner agent takes over and searches the Web in search of good content material in regards to the matter. It creates a plan of content material and sends it to the following agent.
    4. The Author agent receives the writing plan and executes it based on the context and data acquired.
    5. Lastly, the content material is handed to the final agent, the Editor, who critiques the content material and returns the ultimate doc because the output.

    Within the following part, we’ll see how this may be created.

    Code

    CrewAI is a good Python bundle 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, in order for you, you’ll be able to comply with the directions on their Quickstart web page and have a full mission construction created for you with simply a few instructions on a terminal. Principally, it can set up some dependencies, generate the folder construction steered 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 are going to create these folders:

    And these information:

    • Within the config folder: create the information brokers.yaml and duties.yaml
    • Within the data folder, that’s the place I’ll add the information with my writing model.
    • Within the mission root: create crew.py and most important.py.
    Folders construction. Picture by the writer.

    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’ll be able to inform them which position to play.
    • Objective: inform the mannequin what the purpose of that agent is.
    • Backstory: Describe the story behind this agent, who it’s, what it does. 
    writer_style:
      position: >
        Writing Fashion Analyst
      purpose: >
        Totally learn the data base and study the traits of the crew, 
        reminiscent of tone, model, vocabulary, temper, and grammar.
      backstory: >
        You might be an skilled ghost author who can mimic any writing model.
        You know the way to establish the tone and magnificence of the unique author and mimic 
        their writing model.
        Your work is the premise for the Content material Author to write down an article on this matter.

    I received’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’ll do. All of the brokers directions are saved within the brokers.yaml file.

    Consider it as should you have been a supervisor hiring individuals to create a workforce. Take into consideration what varieties of pros you would wish, and what abilities are wanted.

    We want 4 professionals who will work in direction of the ultimate purpose 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 verify the total code within the GitHub repository.

    Duties

    Now, again to the analogy of the supervisor hiring individuals, as soon as we “employed” our complete crew, it’s time to separate the duties. We all know that we wish to produce a weblog put up, we have now 4 brokers, however what every of them will do.

    Nicely, that can be configured within the file duties.yaml.

    As an instance, 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 process to be carried out, similar to we’d inform a brand new rent the right way to carry out their new job. Give exact directions to get the most effective outcome doable.
    • Anticipated output: That is how we wish to see the output. Discover that I give directions like the scale of the weblog put up, the amount of paragraphs, and different data that helps my agent to offer me the anticipated output. 
    • Agent to carry out it: Right here, we’re indicating the agent who will carry out this process, utilizing the identical title set within the brokers.yaml file.
    • Output file: Now all the time 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 put up on {matter}.
        2. Incorporate search engine optimisation key phrases naturally.
        3. Sections/Subtitles are correctly named in an attractive method. Ensure 
        so as to add Introduction, Drawback 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 model.
        6. Use analogies to make the article extra participating and complicated ideas simpler
        to know.
      expected_output: >
        A well-written weblog put up in markdown format, prepared for publication.
        The article should 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 cheap 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 participating
        and factually correct.
      agent: content_writer
      output_file: blog_post.md

    After the brokers and duties are outlined, it’s time to create our crew movement.

    Coding the Crew

    Now we’ll create the file crew.py, the place we’ll translate the beforehand introduced 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, process
    from crewai.data.supply.pdf_knowledge_source import PDFKnowledgeSource
    from crewai_tools import SerperDevTool

    We are going to use the fundamental Agent, Job, Crew, Course of and LLM to create our movement. PDFKnowledgeSource will assist the primary agent studying my writing model, and SerperDevTool is the software to look the web. For that one, ensure that to get your API key at https://serper.dev/signup.

    A finest follow 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’ll use the PDFKnowledgeSource to indicate the Crew the place to seek for the author’s model. By default, that software seems on the data folder of your mission, thus the significance of the title being the identical.

    # Data sources
    
    pdfs = PDFKnowledgeSource(
        file_paths=['article1.pdf',
                    'article2.pdf',
                    'article3.pdf'
                    ]
    )

    Now we will 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 preferred probably the most have been qwen-qwq-32b and gpt-4o. Should you select OpenAI’s, you have to an API Key as effectively. For Qwen-QWQ, simply uncomment the code and remark out the OpenAI’s traces.. 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 have now to create a Crew Base, exhibiting 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 write down a weblog put up"""
        agents_config = "config/brokers.yaml"
        tasks_config = "config/duties.yaml"

    Brokers Capabilities

    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 title of the agent within the config file, the extent of verbosity, being 1 low, 2 excessive. You may also use a Boolean worth, reminiscent of true or false.

    Lastly, we specify if the agent makes use of any software, and what mannequin it can 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 Capabilities

    The following step is creating the duties. Equally to the brokers, we’ll create a perform and adorn it with @process. 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 process created. If any output file is anticipated, use the output_file argument.

    # Configuring the duties    
    
        @process
        def model(self) -> Job:
            return Job(
            config=self.tasks_config['mystyle'],
            )
    
        @process
        def plan(self) -> Job:
            return Job(
            config=self.tasks_config['plan'],
            )
    
        @process
        def write(self) -> Job:
            return Job(
            config=self.tasks_config['write'],
            output_file='output/blog_post.md' # That is the file that can be comprise the ultimate weblog put up.
            )
    
        @process
        def edit(self) -> Job:
            return Job(
            config=self.tasks_config['edit']
            )

    Crew

    To connect every part collectively, we now create a perform and adorn 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 part 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 could be very easy. We create the most important.py file and import the Crew Base BlogWriter created. Then we simply use the features crew().kickoff(inputs) to run it, passing a dictionary with the inputs for use to generate the weblog put up.

    # Script to run the weblog author mission
    
    # Warning management
    import warnings
    warnings.filterwarnings('ignore')
    from crew import BlogWriter
    
    
    def write_blog_post(matter: str):
        # Instantiate the crew
        my_writer = BlogWriter()
        # Run
        outcome = (my_writer
                  .crew()
                  .kickoff(inputs = {
                      'matter': matter
                      })
        )
    
        return outcome
    
    if __name__ == "__main__":
    
        write_blog_post("Worth Optimization with Python")

    There it’s. The result’s a pleasant weblog put up created by the LLM. See under.

    Ensuing weblog put up. GIF by the writer.

    That’s so good!

    Earlier than You Go

    Earlier than you go, know that this weblog put up was 100% created by me. This crew I created was an experiment I needed to do to study extra about the right way to create AI brokers and make them work collectively. And, like I stated, I like writing, so that is one thing I might be capable of 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 put up and code. I might not publish this, however at the very least it may very well be a begin, possibly. 

    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 bundle, exhibits us the right way to create completely 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 comply with my weblog (it’s actually me!), listed here are my contacts and portfolio.

    https://gustavorsantos.me

    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://learn.crewai.com/)



    Source link

    Share. Facebook Twitter Pinterest LinkedIn Tumblr Email
    Previous ArticleThe Complete Guide to NetSuite SuiteScript
    Next Article Exploring Multimodal LLMs? Applications, Challenges, and How They Work
    ProfitlyAI
    • Website

    Related Posts

    Artificial Intelligence

    Not Everything Needs Automation: 5 Practical AI Agents That Deliver Enterprise Value

    June 6, 2025
    Artificial Intelligence

    Prescriptive Modeling Unpacked: A Complete Guide to Intervention With Bayesian Modeling.

    June 6, 2025
    Artificial Intelligence

    5 Crucial Tweaks That Will Make Your Charts Accessible to People with Visual Impairments

    June 6, 2025
    Add A Comment
    Leave A Reply Cancel Reply

    Top Posts

    Q&A: A roadmap for revolutionizing health care through data-driven innovation | MIT News

    May 5, 2025

    Top 10 NLP Trends to Watch in 2025 – Future of AI & Language Processing

    April 4, 2025

    Moore’s Law • AI Parabellum

    April 3, 2025

    27 Free Image Datasets to Boost Your Computer Vision Project

    April 4, 2025

    Mistral har lanserat sin nya AI-modell, Mistral Medium 3

    May 10, 2025
    Categories
    • AI Technology
    • AI Tools & Technologies
    • Artificial Intelligence
    • Latest AI Innovations
    • Latest News
    Most Popular

    Code Agents: The Future of Agentic AI

    May 27, 2025

    Freepik lanserar F Lite en AI-bildgenerator som utmanar branschjättar

    May 1, 2025

    Real-Time Interactive Sentiment Analysis in Python

    May 8, 2025
    Our Picks

    Gemini introducerar funktionen schemalagda åtgärder i Gemini-appen

    June 7, 2025

    AIFF 2025 Runway’s tredje årliga AI Film Festival

    June 7, 2025

    AI-agenter kan nu hjälpa läkare fatta bättre beslut inom cancervård

    June 7, 2025
    Categories
    • AI Technology
    • AI Tools & Technologies
    • Artificial Intelligence
    • Latest AI Innovations
    • Latest News
    • Privacy Policy
    • Disclaimer
    • Terms and Conditions
    • About us
    • Contact us
    Copyright © 2025 ProfitlyAI All Rights Reserved.

    Type above and press Enter to search. Press Esc to cancel.