AI Agents vs. AI Pipelines: A Practical Guide to Coding Your LLM Application

In today’s world, large language models (LLMs) are transforming how we interact with technology. With applications ranging from intelligent chatbots to automated content creators, understanding the underlying architectures of these systems is crucial for developers. This guide delves into the distinctions between AI agents and AI pipelines, exploring their use cases, implementation methods, and providing examples using the CrewAI platform. This guide is crafted to be accessible for readers as young as 12.

Introduction to AI Agents and AI Pipelines

Large language models have become the backbone of many innovative applications. Understanding whether to use an AI agent or an AI pipeline significantly influences the functionality and performance of your applications. This blog post provides clear explanations of both architectures, along with a practical coding approach that even beginners can follow.

Key Concepts

AI Agents

AI agents are semi-autonomous or autonomous entities designed to perform specific tasks. They analyze user inputs and generate appropriate responses based on context, allowing for dynamic interactions. Common applications include:

• Chatbots that assist customers
• Virtual research assistants that help gather information
• Automated writing tools that help produce text content

Example of an AI Agent: Think of a helpful robot that answers your questions about homework or gives you book recommendations based on your interests.

AI Pipelines

AI pipelines refer to a structured flow of data that moves through multiple stages, with each stage performing a specific processing task. This approach is particularly useful for:

• Cleaning and processing large datasets
• Combining results from different models into a cohesive output
• Orchestrating complex workflows that require multiple steps

Example of an AI Pipeline: Imagine a factory assembly line where raw materials pass through various stations, getting transformed into a final product—similar to how data is transformed through the different stages of a pipeline.

Choosing the Right Architecture

The decision to use an AI agent or an AI pipeline largely depends on the specific requirements of your application.

Use Cases for AI Agents

1. Personalized Interactions: For applications needing tailored responses (like customer service).
2. Adaptability: In environments that constantly change, allowing the agent to learn and adjust over time.
3. Contextual Tasks: Useful in scenarios requiring in-depth understanding, such as helping with research or generating creative content.

Use Cases for AI Pipelines

1. Batch Processing: When handling large amounts of data that need consistent processing.
2. Hierarchical Workflows: For tasks like data cleaning followed by enrichment and final output generation.
3. Multi-Step Processes: Where the output of one model serves as input for another.

Coding Your LLM Application with CrewAI

CrewAI offers a robust platform to simplify the process of developing LLM applications. Below, we provide code samples to demonstrate how easily you can create both an AI agent and an AI pipeline using CrewAI.

Example of Creating an AI Agent

# Import the necessary libraries
from crewai import Agent
from langchain.agents import load_tools

# Human Tools
human_tools = load_tools(["human"])

class YoutubeAutomationAgents():
    def youtube_manager(self):
        return Agent(
            role="YouTube Manager",
            goal="""Oversee the YouTube prepration process including market research, title ideation, 
                description, and email announcement creation reqired to make a YouTube video.
                """,
            backstory="""As a methodical and detailed oriented managar, you are responsible for overseeing the preperation of YouTube videos.
                When creating YouTube videos, you follow the following process to create a video that has a high chance of success:
                1. Search YouTube to find a minimum of 15 other videos on the same topic and analyze their titles and descriptions.
                2. Create a list of 10 potential titles that are less than 70 characters and should have a high click-through-rate.
                    -  Make sure you pass the list of 1 videos to the title creator 
                        so that they can use the information to create the titles.
                3. Write a description for the YouTube video.
                4. Write an email that can be sent to all subscribers to promote the new video.
                """,
            allow_delegation=True,
            verbose=True,
        )

    def research_manager(self, youtube_video_search_tool, youtube_video_details_tool):
        return Agent(
            role="YouTube Research Manager",
            goal="""For a given topic and description for a new YouTube video, find a minimum of 15 high-performing videos 
                on the same topic with the ultimate goal of populating the research table which will be used by 
                other agents to help them generate titles  and other aspects of the new YouTube video 
                that we are planning to create.""",
            backstory="""As a methodical and detailed research managar, you are responsible for overseeing researchers who 
                actively search YouTube to find high-performing YouTube videos on the same topic.""",
            verbose=True,
            allow_delegation=True,
            tools=[youtube_video_search_tool, youtube_video_details_tool]
        )

    def title_creator(self):
        return Agent(
            role="Title Creator",
            goal="""Create 10 potential titles for a given YouTube video topic and description. 
                You should also use previous research to help you generate the titles.
                The titles should be less than 70 characters and should have a high click-through-rate.""",
            backstory="""As a Title Creator, you are responsible for creating 10 potential titles for a given 
                YouTube video topic and description.""",
            verbose=True
        )

    def description_creator(self):
        return Agent(
            role="Description Creator",
            goal="""Create a description for a given YouTube video topic and description.""",
            backstory="""As a Description Creator, you are responsible for creating a description for a given 
                YouTube video topic and description.""",
            verbose=True
        )

    def email_creator(self):
        return Agent(
            role="Email Creator",
            goal="""Create an email to send to the marketing team to promote the new YouTube video.""",
            backstory="""As an Email Creator, you are responsible for creating an email to send to the marketing team 
                to promote the new YouTube video.

                It is vital that you ONLY ask for human feedback after you've created the email.
                Do NOT ask the human to create the email for you.
                """,
            verbose=True,
            tools=human_tools
        )

Step-by-step Breakdown:

1. Import Libraries: Import the CrewAI library to access its features.
2. Initialize Environment: Create a Crew object linked to your API Key.
3. Create an Agent: We define an AI Agent called "ResearchAssistant" that utilizes the GPT-3 model.
4. Function: The generate_response function takes a user’s question and returns the AI’s reply.
5. Test Query: We test our agent by providing it with a sample query about AI advancements, printing the AI’s response.

Example of Setting Up an AI Pipeline

# Setting up AI Pipeline using CrewAI
pipeline = crew.create_pipeline(name="DataProcessingPipeline")

# Adding models to the pipeline with processing steps
pipeline.add_model("DataCleaner")
pipeline.add_model("ModelInference", model=LLMModel.GPT_3)

# Run the pipeline with input data
pipeline_output = pipeline.run(input_data="Raw data that needs processing.")
print("Pipeline Output:", pipeline_output)

Step-by-Step Breakdown

Step 1: Import Necessary Libraries

from crewai import Agent
from langchain.agents import load_tools

• Import the Agent Class: Import the Agent class from crewai, which allows the creation of agents that can perform specific roles.
• Import load_tools: Import load_tools from langchain.agents to access tools that the agents might use. Here, it is used to load tools that require human input.

Step 2: Load Human Tools

# Human Tools
human_tools = load_tools(["human"])

• Load Human Interaction Tools: Load a set of tools that allow the AI agents to ask for feedback or interact with a human. These tools enable agents to involve humans in certain tasks (e.g., providing feedback).

Step 3: Define the YoutubeAutomationAgents Class

class YoutubeAutomationAgents():
    ...

• Class for YouTube Automation Agents: Create a class called YoutubeAutomationAgents to encapsulate all the agents related to the YouTube video preparation process.

Step 4: Create youtube_manager Method

def youtube_manager(self):
    return Agent(
        role="YouTube Manager",
        goal="""Oversee the YouTube preparation process including market research, title ideation, 
                description, and email announcement creation required to make a YouTube video.
                """,
        backstory="""As a methodical and detail-oriented manager, you are responsible for overseeing the preparation of YouTube videos.
                When creating YouTube videos, you follow the following process to create a video that has a high chance of success:
                1. Search YouTube to find a minimum of 15 other videos on the same topic and analyze their titles and descriptions.
                2. Create a list of 10 potential titles that are less than 70 characters and should have a high click-through-rate.
                    - Make sure you pass the list of videos to the title creator 
                      so that they can use the information to create the titles.
                3. Write a description for the YouTube video.
                4. Write an email that can be sent to all subscribers to promote the new video.
                """,
        allow_delegation=True,
        verbose=True,
    )

• Agent Role: "YouTube Manager" – this agent is responsible for overseeing the entire YouTube video preparation process.
• Goal: Manage and coordinate the processes required to create a successful YouTube video, including research, title ideation, and description writing.
• Backstory: Provides a detailed description of the responsibilities, outlining the process to ensure the video has a high chance of success.
• allow_delegation=True: This enables the agent to delegate tasks to other agents.
• verbose=True: Enables detailed logging of the agent’s actions for better understanding and debugging.

Step 5: Create research_manager Method

def research_manager(self, youtube_video_search_tool, youtube_video_details_tool):
    return Agent(
        role="YouTube Research Manager",
        goal="""For a given topic and description for a new YouTube video, find a minimum of 15 high-performing videos 
                on the same topic with the ultimate goal of populating the research table which will be used by 
                other agents to help them generate titles and other aspects of the new YouTube video 
                that we are planning to create.""",
        backstory="""As a methodical and detailed research manager, you are responsible for overseeing researchers who 
                actively search YouTube to find high-performing YouTube videos on the same topic.""",
        verbose=True,
        allow_delegation=True,
        tools=[youtube_video_search_tool, youtube_video_details_tool]
    )

• Agent Role: "YouTube Research Manager" – this agent focuses on finding relevant high-performing videos for a given topic.
• Goal: Find at least 15 videos on the same topic, which will help in generating other video components like titles.
• Backstory: Explains the agent’s focus on research and how this information will aid in creating successful video content.
• Tools: Uses youtube_video_search_tool and youtube_video_details_tool to search and analyze YouTube videos.
• allow_delegation=True: Allows the agent to delegate tasks to other agents as necessary.

Step 6: Create title_creator Method

def title_creator(self):
    return Agent(
        role="Title Creator",
        goal="""Create 10 potential titles for a given YouTube video topic and description. 
                You should also use previous research to help you generate the titles.
                The titles should be less than 70 characters and should have a high click-through-rate.""",
        backstory="""As a Title Creator, you are responsible for creating 10 potential titles for a given 
                YouTube video topic and description.""",
        verbose=True
    )

• Agent Role: "Title Creator" – focuses on generating titles.
• Goal: Create 10 potential titles for a given topic, using previous research to ensure they have high click-through rates.
• Backstory: Describes the agent’s role in creating engaging and optimized titles.
• verbose=True: For detailed output during the agent’s actions.

Step 7: Create description_creator Method

def description_creator(self):
    return Agent(
        role="Description Creator",
        goal="""Create a description for a given YouTube video topic and description.""",
        backstory="""As a Description Creator, you are responsible for creating a description for a given 
                YouTube video topic and description.""",
        verbose=True
    )

• Agent Role: "Description Creator" – specializes in writing video descriptions.
• Goal: Create a compelling description for the video.
• Backstory: Provides context for the agent’s expertise in writing video descriptions.
• verbose=True: Enables detailed output.

Step 8: Create email_creator Method

def email_creator(self):
    return Agent(
        role="Email Creator",
        goal="""Create an email to send to the marketing team to promote the new YouTube video.""",
        backstory="""As an Email Creator, you are responsible for creating an email to send to the marketing team 
                to promote the new YouTube video.

                It is vital that you ONLY ask for human feedback after you've created the email.
                Do NOT ask the human to create the email for you.
                """,
        verbose=True,
        tools=human_tools
    )

• Agent Role: "Email Creator" – focuses on creating email content to promote the new video.
• Goal: Write a marketing email for the new video.
• Backstory: Emphasizes that the agent should complete the email itself and only seek human feedback once the draft is ready.
• Tools: Uses human_tools to gather feedback after drafting the email.
• verbose=True: Enables detailed logging for transparency during the process.

Summary

This class defines a set of agents, each with specific roles and goals, to handle different parts of the YouTube video preparation process:

• YouTube Manager oversees the entire process.
• Research Manager finds existing relevant videos.
• Title Creator generates engaging titles.
• Description Creator writes video descriptions.
• Email Creator drafts marketing emails and seeks human feedback.

These agents, when combined, enable a structured approach to creating a successful YouTube video. Each agent can focus on its specialty, ensuring the video preparation process is efficient and effective.

Best Practices

1. Understand Requirements: Clearly outline the goals of your application to guide architectural decisions.
2. Iterative Development: Start with a minimal viable product that addresses core functionalities, expanding complexity over time.
3. Monitoring and Observability: Implement tools to monitor performance and make necessary adjustments post-deployment.
4. Experiment with Both Architectures: Utilize A/B testing to discover which option better meets your application’s needs.

Conclusion

Both AI agents and AI pipelines are vital tools for leveraging large language models effectively. By carefully choosing the right approach for your application’s requirements and utilizing platforms like CrewAI, developers can create high-performing and user-friendly applications. As technology advances, staying informed about these architectures will enable developers to keep pace with the evolving landscape of AI applications.

The world of AI is expansive and filled with opportunities. With the right knowledge and tools at your disposal, you can create remarkable applications that harness the power of language and data. Happy coding!

References

1. Large Language Models for Code Generation | FabricHQ AI Pipelines: A Practical Guide to Coding Your LLM…
2. Using Generative AI to Automatically Create a Video Talk from an … AI Pipelines: A Practical Guide to Coding Your LLM … create apps that dem…
3. Data Labeling — How to Select a Data Labeling Company? | by … AI Pipelines: A Practical Guide to Coding Your LLM App…
4. SonarQube With OpenAI Codex – Better Programming AI Pipelines: A Practical Guide to Coding Your LLM Application … create apps…
5. Best AI Prompts for Brainboard AI | by Mike Tyson of the Cloud (MToC) … Guide to Coding Your LLM Application. We use CrewA…
6. How to take help from AI Agents for Research and Writing: A project The Researcher agent’s role is to find relevant academic papers, while…
7. Towards Data Science on LinkedIn: AI Agents vs. AI Pipelines Not sure how to choose the right architecture for your LLM application? Al…
8. Inside Ferret-UI: Apple’s Multimodal LLM for Mobile … – Towards AI … Application. We use CrewAI to create apps that demonstra…
9. The role of UX in AI-driven healthcare | by Roxanne Leitão | Sep, 2024 AI Pipelines: A Practical Guide to Coding Your LLM … create apps that de…
10. Build Your Own Autonomous Agents using OpenAGI – AI Planet Imagine AI agents as your digital sidekicks, tirelessly working t…

Citations

1. Multi-agent system’s architecture. | by Talib – Generative AI AI Pipelines: A Practical Guide to Coding Your LLM … create apps that dem…
2. What is LLM Orchestration? – IBM As organizations adopt artificial intelligence to build these sorts of generativ…
3. Amazon Bedrock: Building a solid foundation for Your AI Strategy … Application. We use CrewAI to create apps that demonstrate how to choo…
4. Connect CrewAI to LLMs … set. You can easily configure your agents to use a differe…
5. I trusted OpenAI to help me learn financial analysis. I’m now a (much … AI Pipelines: A Practical Guide to Coding Your LLM … creat…
6. Prompt Engineering, Multi-Agency and Hallucinations are … AI Pipelines: A Practical Guide to Coding Your LLM … cre…
7. Announcing the next Betaworks Camp program — AI Camp: Agents AI Agents vs. AI Pipelines: A Practical Guide to Coding…
8. AI and LLM Observability With KloudMate and OpenLLMetry AI Pipelines: A Practical Guide to Coding Your LLM ……
9. Get Started with PromptFlow — Microsoft High-Quality AI App … AI Pipelines: A Practical Guide to Coding Your LLM ……

10. From Buzzword to Understanding: Demystifying Generative AI AI Pipelines: A Practical Guide to Coding Your LLM … create apps…

    ---

    Join the conversation on LinkedIn—let’s connect and share insights here!

    Explore more about AI&U on our website here.