Introduction

The demand for efficient software development is driving the adoption of artificial intelligence as a valuable programming partner. AI-powered coding assistants are revolutionizing development by simplifying code writing, debugging, and optimization, much like a human pair programmer. This article demonstrates building an AI pair programmer using CrewAI agents to streamline coding tasks and boost developer productivity.

Overview

This guide covers:

• Understanding CrewAI's role in assisting coding tasks.
• Identifying key components: Agents, Tasks, Tools, and Crews, and their interactions.
• Practical experience setting up AI agents for code generation and review.
• Configuring multiple AI agents for collaborative coding.
• Utilizing CrewAI to assess and optimize code quality.

Table of contents

• Qualitative Examples of NVLM 1.0 D 74B
• Comparison of NVLM with Other LLMs
• Limitations of other Multimodal LLMs
• Addressing those limitations
• NVLM: Models and Training Methods
• Training Data
• Results
• Accessing NVLM D 72B
  • Importing necessary libraries
  • Model Sharding
  • Image Preprocessing
  • Dynamic image tiling
  • Loading and Preprocessing Images
  • Loading and Using the Model
  • Text and Image Conversations
• Frequently Asked Questions

AI Pair Programmer Capabilities

An AI pair programmer offers several advantages:

1. Code generation: Generate code for a given problem using one AI agent and review it with another.
2. Code improvement: Evaluate existing code based on specified criteria.
3. Code optimization: Request code enhancements, such as adding comments or docstrings.
4. Debugging: Receive suggestions for resolving code errors.
5. Test case generation: Generate test cases for various scenarios, including test-driven development.

This article focuses on the first two capabilities.

What is CrewAI?

CrewAI is a framework for creating AI agents. Its key components are:

• Agent: An agent uses a large language model (LLM) to produce outputs based on input prompts. It interacts with tools, accepts user input, and communicates with other agents.
• Task: Defines the agent's objective, including description, agent, and usable tools.
• Tool: Agents use tools for tasks like web searches, file reading, and code execution.
• Crew: A group of agents collaborating on tasks, defining interaction, information sharing, and responsibility delegation.

Also Read: Building Collaborative AI Agents With CrewAI

Let's build an agent to illustrate these concepts.

Prerequisites

Before building an AI pair programmer, obtain API keys for LLMs.

Accessing an LLM via API

Generate an API key for your chosen LLM and store it securely in a .env file for project access while maintaining privacy.

Example .env File

A sample .env file:

Required Libraries

The following library versions are used:

• crewai – 0.66.0
• crewai-tools – 0.12.1

Automating Code Creation

This section demonstrates importing libraries and defining agents for code generation and review.

Importing Libraries

from dotenv import load_dotenv
load_dotenv('/.env')

from crewai import Agent, Task, Crew

Defining the Code Writer Agent

One agent generates code, another reviews it.

code_writer_agent = Agent(role="Software Engineer",
                          goal='Write optimized and maintainable code, including docstrings and comments', 
                          backstory="""You are a software engineer writing optimized, maintainable code with docstrings and comments.""",
                          llm='gpt-4o-mini',
                          verbose=True)

Agent Parameters Explained

• role: Defines the agent's function.
• goal: Specifies the agent's objective.
• backstory: Provides context for better interaction.
• llm: Specifies the LLM used (see LiteLLM documentation for options).
• verbose: Enables detailed input/output logging.

Defining the Code Writer Task

code_writer_task = Task(description='Write code to solve the problem in {language}. Problem: {problem}',
                        expected_output='Well-formatted code with type hinting',
                        agent=code_writer_agent)

Task Parameters Explained

• description: Clear task objective with variables ({language}, {problem}).
• expected_output: Desired output format.
• agent: The agent assigned to the task.

Defining the Code Reviewer Agent and Task

Similarly, define code_reviewer_agent and code_reviewer_task.

code_reviewer_agent = Agent(role="Senior Software Engineer",
                            goal='Ensure code is optimized and maintainable', 
                            backstory="""You are a senior engineer reviewing code for readability, maintainability, and performance.""",
                            llm='gpt-4o-mini',
                            verbose=True)

code_reviewer_task = Task(description="""Review code written for the problem in {language}. Problem: {problem}""",
                          expected_output='Reviewed code',
                          agent=code_reviewer_agent)

Building and Running the Crew

Create and run the crew:

crew = Crew(agents=[code_writer_agent, code_reviewer_agent], 
            tasks=[code_writer_task, code_reviewer_task], 
            verbose=True)

result = crew.kickoff(inputs={'problem': 'create a tic-tac-toe game', 'language': 'Python'})            

Sample output:

Result Analysis

The result object contains:

result.dict().keys()
>>> dict_keys(['raw', 'pydantic', 'json_dict', 'tasks_output', 'token_usage'])

# Token usage
result.dict()['token_usage']
>>> {'total_tokens': 2656, ...}

# Final output
print(result.raw)

The generated code can then be executed.

Automated Code Evaluation

This section covers evaluating existing code.

Defining Evaluation Requirements

First, gather requirements using an agent, then evaluate the code based on those requirements using another agent.

Using Tools

The FileReadTool reads files. Tools enhance agent capabilities. Tools can be assigned to tasks and agents; task-level assignments override agent-level assignments.

Setting up Requirement Gathering Agent and Task

from crewai_tools import FileReadTool

code_requirements_agent = Agent(role="Data Scientist",
                          goal='Define code requirements for a given problem.', 
                          backstory="""You are a Data Scientist defining requirements for code to solve a problem.""",
                          llm='gpt-4o-mini',
                          verbose=True)

code_requirement_task = Task(description='Write step-by-step requirements. Problem: {problem}',
                            expected_output='Formatted requirements text.',
                            agent=code_requirements_agent,
                            human_input=True)                         

human_input=True allows user input for adjustments.

Code Evaluation

This example uses FileReadTool and gpt-4o for better handling of larger contexts.

file_read_tool = FileReadTool('EDA.py')

code_evaluator_agent = Agent(role="Data Science Evaluator",
                            goal='Evaluate code based on provided requirements', 
                            backstory="""You are a Data Science evaluator reviewing code based on given requirements.""",
                            llm='gpt-4o',
                            verbose=True)

code_evaluator_task = Task(description="""Evaluate the code file based on the requirements.  Provide only the evaluation, not the code.""",
                           expected_output='Detailed evaluation based on requirements.',
                           tools=[file_read_tool],
                           agent=code_evaluator_agent)                            

Building the Evaluation Crew

Create the crew and define the problem:

crew = Crew(agents=[code_requirements_agent, code_evaluator_agent], 
            tasks=[code_requirement_task, code_evaluator_task], 
            verbose=True)

problem = """Perform EDA on the NYC taxi trip duration dataset...""" # (Dataset description omitted for brevity)

result = crew.kickoff(inputs={'problem': problem})

Output

The output shows human input prompts:

Task outputs can be accessed individually:

print(code_requirement_task.output.raw)
print(result.raw)

Conclusion

CrewAI provides a powerful framework for enhancing software development through AI-driven code generation, review, and evaluation. By defining roles, goals, and tasks, developers can streamline workflows and boost productivity. Integrating an AI pair programmer with CrewAI improves efficiency and code quality. CrewAI's flexibility facilitates seamless AI agent collaboration, resulting in optimized, maintainable, and error-free code. As AI evolves, CrewAI's pair programming capabilities will become increasingly valuable for developers.

Frequently Asked Questions

Q1. What is CrewAI and its role in software development? CrewAI is an AI agent framework assisting developers with code writing, review, and evaluation, boosting productivity.

Q2. What are CrewAI's key components? Agents, Tasks, Tools, and Crews. Agents perform actions; Tasks define objectives; Tools extend agent capabilities; Crews enable agent collaboration.

Q3. How to set up a code-generating AI agent? Define the agent's role, goal, backstory, and LLM, then create a corresponding Task specifying the problem and expected output.

Q4. Can CrewAI agents collaborate? Yes, through "Crews," allowing agents to handle different aspects of a task efficiently.

Q5. What tools are available? Various tools enhance agent capabilities, including file reading, web searches, and code execution.

The above is the detailed content of Build AI Pair Programmer with CrewAI - Analytics Vidhya. For more information, please follow other related articles on the PHP Chinese website!