Complete DevOps Pipeline Orchestration with Apply Patch & Shell Tools#
This notebook demonstrates a complete end-to-end DevOps pipeline orchestration using AG2’s support for OpenAI’s built-in apply_patch and shell tools. The system creates projects from scratch, develops code, tests, fixes issues, sets up CI/CD, builds, and deploys applications.
Overview#
This orchestration showcases:
- Apply Patch Tool: For structured file operations (create, update, delete files)
- Shell Tool: For executing commands (tests, builds, deployments, validation)
Use Case: Full Lifecycle DevOps Pipeline#
From project creation → coding → testing → fixing → CI/CD setup → deployment → validation
Orchestration Flow#
┌─────────────────────────────────────────────────────────────────────────┐
│ USER REQUEST │
│ "Create a complete web application" │
└─────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────┐
│ 🎯 PIPELINE ORCHESTRATOR │
│ • Analyzes request │
│ • Routes to appropriate agent │
│ • Coordinates workflow │
└─────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────┐
│ 🏗️ PROJECT CREATOR │
│ Uses APPLY_PATCH tool: │
│ • Create project structure │
│ • Initialize config files │
│ • Set up directories │
│ • Create initial templates │
└─────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────┐
│ 💻 CODE DEVELOPER │
│ Uses APPLY_PATCH tool: │
│ • Write application code │
│ • Implement features │
│ • Create modules and classes │
│ • Write unit tests │
└─────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────┐
│ 🔍 CODE QUALITY ANALYZER │
│ Uses SHELL tool: │
│ • Run test suites (pytest, unittest) │
│ • Run linters (pylint, flake8) │
│ • Check git status │
│ • Analyze code coverage │
│ • Check build status │
└─────────────────────────────────────────────────────────────────────────┘
│
┌─────────┴─────────┐
│ │
Issues Found? All Checks Pass?
│ │
▼ ▼
┌───────────────────────────┐ ┌──────────────────────────────┐
│ 🔧 CODE FIXER │ │ ⚙️ CONFIGURATION MANAGER │
│ Uses APPLY_PATCH tool: │ │ Uses APPLY_PATCH tool: │
│ • Fix bugs │ │ • Create CI/CD configs │
│ • Resolve linting errors │ │ • Update environment files │
│ • Refactor code │ │ • Create Docker configs │
│ • Add missing tests │ │ • Update deployment scripts │
└───────────────────────────┘ └──────────────────────────────┘
│ │
└─────────┬─────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────┐
│ 🚀 BUILD & DEPLOY AGENT │
│ Uses SHELL tool: │
│ • Install dependencies │
│ • Build applications │
│ • Run deployment scripts │
│ • Push to repositories │
│ • Manage containers │
└─────────────────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────┐
│ ✅ DEPLOYMENT VALIDATOR │
│ Uses SHELL tool: │
│ • Run health checks │
│ • Execute smoke tests │
│ • Check service status │
│ • Verify endpoints │
│ • Monitor resource usage │
└─────────────────────────────────────────────────────────────────────────┘
│
┌─────────┴─────────┐
│ │
All Checks Pass? Issues Found?
│ │
▼ ▼
┌───────────────────────────┐ ┌──────────────────────────────┐
│ 🎯 PIPELINE ORCHESTRATOR│ │ Route back to CODE FIXER │
│ Report SUCCESS │ │ or CONFIG MANAGER │
└───────────────────────────┘ └──────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────┐
│ USER RECEIVES REPORT │
│ Complete pipeline status and results │
└─────────────────────────────────────────────────────────────────────────┘
Agent Responsibilities#
1. 🎯 Pipeline Orchestrator#
- Role: Central coordinator
- Responsibilities:
- Analyze user requests
- Route tasks to appropriate agents
- Monitor pipeline progress
- Report final results
- Tools Used: None (coordination only)
2. 🏗️ Project Creator#
- Role: Initialize new projects
- Responsibilities:
- Create project structure
- Generate initial files (README, .gitignore, LICENSE)
- Set up configuration files
- Create directory structure
- Tools Used: APPLY_PATCH (file creation)
3. 💻 Code Developer#
- Role: Write application code
- Responsibilities:
- Implement features
- Create modules and classes
- Add business logic
- Write unit tests
- Tools Used: APPLY_PATCH (code writing)
4. 🔍 Code Quality Analyzer#
- Role: Test and analyze code quality
- Responsibilities:
- Run test suites
- Execute linters
- Check code coverage
- Validate build status
- Tools Used: SHELL (command execution)
5. 🔧 Code Fixer#
- Role: Fix code issues
- Responsibilities:
- Fix bugs
- Resolve linting errors
- Refactor code
- Add missing tests
- Tools Used: APPLY_PATCH (code modifications)
6. ⚙️ Configuration Manager#
- Role: Manage configurations
- Responsibilities:
- Create CI/CD configs
- Update environment files
- Create Docker configs
- Update deployment scripts
- Tools Used: APPLY_PATCH (config file operations)
7. 🚀 Build & Deploy Agent#
- Role: Build and deploy applications
- Responsibilities:
- Install dependencies
- Build applications
- Run deployment scripts
- Manage containers
- Tools Used: SHELL (build and deployment commands)
8. ✅ Deployment Validator#
- Role: Validate deployments
- Responsibilities:
- Run health checks
- Execute smoke tests
- Check service status
- Verify endpoints
- Tools Used: SHELL (validation commands)
Installation and Setup#
Import Dependencies#
import os
from dotenv import load_dotenv
from autogen import ConversableAgent, LLMConfig, UserProxyAgent
from autogen.agentchat import initiate_group_chat
from autogen.agentchat.group.patterns.auto import AutoPattern
load_dotenv()
Configure LLM with Built-in Tools#
We configure the LLM to use both apply_patch_async and shell tools:
- apply_patch_async: For structured file operations (create, update, delete)
- shell: For executing shell commands (tests, builds, deployments)
- workspace_dir: Directory where all operations will be performed
# Configure LLM with both built-in tools
llm_config = LLMConfig(
config_list={
"api_type": "responses",
"model": "gpt-5.1",
"api_key": os.getenv("OPENAI_API_KEY"),
"built_in_tools": ["apply_patch_async", "shell"],
"workspace_dir": "./project_dir",
},
)
Agent Definitions#
Agent 1: Pipeline Orchestrator#
The orchestrator acts as the central coordinator, analyzing requests and routing to appropriate agents.
orchestrator = ConversableAgent(
name="pipeline_orchestrator",
system_message="""🎯 You are the Pipeline Orchestrator. Your role is to:
• Analyze user requests and determine the workflow path
• Route tasks to appropriate specialized agents
• Monitor pipeline progress and coordinate handoffs
• Report final results to the user
Workflow Decision Logic:
┌─────────────────────────────────────────────────────────┐
│ 1. New project request? → Route to project_creator │
│ 2. Code development? → Route to code_developer │
│ 3. Code analysis needed? → Route to code_quality_analyzer│
│ 4. Configuration updates? → Route to config_manager │
│ 5. Build/deploy request? → Route to build_deploy_agent │
│ 6. Validation needed? → Route to deployment_validator │
└─────────────────────────────────────────────────────────┘
Always provide clear routing decisions with reasoning.""",
llm_config=llm_config,
)
Agent 2: Project Creator#
Uses APPLY_PATCH tool to create project structure and initial files.
project_creator = ConversableAgent(
name="project_creator",
system_message="""🏗️ You are the Project Creator. Your role is to:
Use the APPLY_PATCH tool to:
✓ Create project structure and directories
✓ Generate initial files (README.md, .gitignore, LICENSE)
✓ Set up configuration files (package.json, requirements.txt, pom.xml)
✓ Create initial source code templates
✓ Set up test directory structure
Project Creation Checklist:
┌──────────────────────────────────────────────┐
│ □ Project directory structure created? │
│ □ Configuration files initialized? │
│ □ Initial source code files created? │
│ □ Test directory structure set up? │
│ □ Documentation files added? │
└──────────────────────────────────────────────┘
After project creation:
→ Route to code_developer for implementation
Create clean, well-structured project foundations.""",
llm_config=llm_config,
)
Agent 3: Code Developer#
Uses APPLY_PATCH tool to write application code and implement features.
code_developer = ConversableAgent(
name="code_developer",
system_message="""💻 You are the Code Developer. Your role is to:
Use the APPLY_PATCH tool to:
✓ Write application code and implement features
✓ Create modules, classes, and functions
✓ Add business logic and algorithms
✓ Implement API endpoints and routes
✓ Write unit tests for new code
Development Guidelines:
┌──────────────────────────────────────────────┐
│ 1. Follow best practices and coding standards│
│ 2. Write clean, maintainable code │
│ 3. Include proper error handling │
│ 4. Add comprehensive unit tests │
│ 5. Document complex logic │
└──────────────────────────────────────────────┘
After development:
→ Route to code_quality_analyzer for testing and validation
Write production-ready code with tests!""",
llm_config=llm_config,
)
Agent 4: Code Quality Analyzer#
Uses SHELL tool to run tests, linters, and analyze code quality.
code_analyzer = ConversableAgent(
name="code_quality_analyzer",
system_message="""🔍 You are the Code Quality Analyzer. Your role is to:
Use the SHELL tool to:
✓ Run test suites: pytest, unittest, npm test, mvn test
✓ Run linters: pylint, flake8, black --check, eslint, prettier
✓ Check git status: git status, git diff, git log
✓ Analyze code coverage: coverage report, pytest --cov
✓ Check build status: npm run build, mvn compile
Analysis Checklist:
┌──────────────────────────────────────────────┐
│ □ All tests passing? │
│ □ No linting errors? │
│ □ Code coverage acceptable? │
│ □ No merge conflicts? │
│ □ Build successful? │
└──────────────────────────────────────────────┘
Routing Rules:
• Issues found → Route to code_fixer
• All checks pass → Route to config_manager for CI/CD setup
Provide detailed analysis reports with specific issues identified.""",
llm_config=llm_config,
)
Agent 5: Code Fixer#
Uses APPLY_PATCH tool to fix bugs and resolve issues found during analysis.
code_fixer = ConversableAgent(
name="code_fixer",
system_message="""🔧 You are the Code Fixer. Your role is to:
Use the APPLY_PATCH tool to:
✓ Fix bugs identified by tests
✓ Resolve linting errors
✓ Refactor code for better quality
✓ Add missing tests
✓ Update documentation
Fixing Guidelines:
┌──────────────────────────────────────────────┐
│ 1. Fix one issue at a time │
│ 2. Use precise diffs (unified diff format) │
│ 3. Maintain code style consistency │
│ 4. Add tests for new fixes │
│ 5. Update related documentation │
└──────────────────────────────────────────────┘
After applying fixes:
→ Always route back to code_quality_analyzer for re-validation
Never skip validation after fixes!""",
llm_config=llm_config,
)
Agent 6: Configuration Manager#
Uses APPLY_PATCH tool to create and update CI/CD configurations, Docker files, and deployment scripts.
config_manager = ConversableAgent(
name="config_manager",
system_message="""⚙️ You are the Configuration Manager. Your role is to:
Use the APPLY_PATCH tool to:
✓ Create/update CI/CD configurations (.github/workflows/*.yml, .gitlab-ci.yml)
✓ Create/update environment files (.env, .env.example, config.yaml)
✓ Create/update deployment scripts (deploy.sh, docker-compose.yml)
✓ Update build configurations (package.json, pom.xml, requirements.txt)
✓ Create Dockerfile and containerization configs
Configuration Types:
┌──────────────────────────────────────────────┐
│ • CI/CD Pipeline Configs │
│ • Environment Variables │
│ • Docker & Container Configs │
│ • Build & Dependency Files │
│ • Deployment Scripts │
└──────────────────────────────────────────────┘
After updating configs:
→ Route to build_deploy_agent for execution
Always validate config syntax before routing!""",
llm_config=llm_config,
)
Agent 7: Build & Deploy Agent#
Uses SHELL tool to install dependencies, build applications, and deploy services.
build_deploy_agent = ConversableAgent(
name="build_deploy_agent",
system_message="""🚀 You are the Build & Deploy Agent. Your role is to:
Use the SHELL tool to:
✓ Install dependencies: npm install, pip install -r requirements.txt, mvn install
✓ Build applications: npm run build, mvn package, docker build
✓ Run deployment scripts: ./deploy.sh, kubectl apply
✓ Push to repositories: git push, docker push
✓ Manage containers: docker-compose up, docker run
✓ Start services: systemctl start, pm2 start
Build & Deploy Checklist:
┌──────────────────────────────────────────────┐
│ □ Dependencies installed correctly? │
│ □ Build completed successfully? │
│ □ Docker images built and tagged? │
│ □ Deployment scripts executed? │
│ □ Services started successfully? │
└──────────────────────────────────────────────┘
After deployment:
→ Route to deployment_validator for verification
Report build/deploy status with timestamps and logs.""",
llm_config=llm_config,
)
Agent 8: Deployment Validator#
Uses SHELL tool to validate deployments by running health checks and smoke tests.
deployment_validator = ConversableAgent(
name="deployment_validator",
system_message="""✅ You are the Deployment Validator. Your role is to:
Use the SHELL tool to:
✓ Run health checks: curl http://endpoint/health, wget --spider
✓ Execute smoke tests: npm run smoke-test, pytest tests/smoke
✓ Check service status: docker ps, kubectl get pods, systemctl status
✓ Verify endpoints: curl API endpoints, check logs
✓ Monitor resource usage: top, htop, docker stats
Validation Checklist:
┌──────────────────────────────────────────────┐
│ □ Health endpoints responding? │
│ □ Smoke tests passing? │
│ □ Services running correctly? │
│ □ No critical errors in logs? │
│ □ Performance metrics acceptable? │
└──────────────────────────────────────────────┘
After validation:
• All checks pass → Route to pipeline_orchestrator (SUCCESS)
• Issues found → Route to code_fixer or config_manager (FAILURE)
Provide detailed validation reports with metrics.""",
llm_config=llm_config,
)
User Agent Configuration#
user = UserProxyAgent(
name="user", human_input_mode="TERMINATE", code_execution_config={"work_dir": "coding", "use_docker": False}
)
Orchestration Pattern Setup#
We use AutoPattern which allows the LLM to intelligently select the next speaker based on conversation context. This provides more dynamic and adaptive conversation flow compared to DefaultPattern.
pattern = AutoPattern(
initial_agent=orchestrator,
agents=[
orchestrator,
project_creator,
code_developer,
code_analyzer,
code_fixer,
config_manager,
build_deploy_agent,
deployment_validator,
],
user_agent=user,
group_manager_args={"llm_config": llm_config},
)
Execute the Pipeline#
This example creates a complete REST API for a task management system from scratch, going through the entire development lifecycle.
result, context, last_agent = initiate_group_chat(
pattern=pattern,
messages="""🚀 Create a complete web application from scratch use apply patch and shell tools:
Project: Build a REST API for a task management system
Requirements:
1. Create project structure (Python FastAPI application)
2. Implement core features:
- Task CRUD operations
- User authentication
- Task filtering and search
3. Write comprehensive unit tests
4. Set up CI/CD pipeline (GitHub Actions)
5. Create Docker configuration
6. Build and deploy the application
7. Validate deployment
Start from project creation and go through the complete development lifecycle.""",
max_rounds=30,
)
Tool Usage Summary#
Apply Patch Tool Usage#
| Agent | Use Case | Operations |
|---|---|---|
| Project Creator | Create project structure | create_file for directories, config files, templates |
| Code Developer | Write application code | create_file, update_file for source code and tests |
| Code Fixer | Fix bugs and issues | update_file with unified diffs to fix code |
| Configuration Manager | Manage configs | create_file, update_file for CI/CD, Docker, env files |
,
| Agent | Use Case | Commands |
|---|---|---|
| Code Quality Analyzer | Test and analyze | pytest, pylint, flake8, git status, coverage |
| Build & Deploy Agent | Build and deploy | pip install, npm build, docker build, docker-compose up |
| Deployment Validator | Validate deployment | curl, pytest tests/smoke, docker ps, systemctl status |
Shell Tool Usage#
Key Benefits#
- Structured File Operations: Apply patch tool ensures precise, controlled file modifications
- Command Execution: Shell tool enables testing, building, and deployment automation
- Complete Lifecycle: From project creation to deployment validation
- Iterative Improvement: Automatic routing back to fixers when issues are found
- Production Ready: Real-world DevOps workflow implementation
Next Steps#
- Customize agent system messages for your specific use case
- Adjust workspace directory and paths
- Modify handoff conditions for different workflows
- Add more specialized agents as needed
- Integrate with external tools and services