### UI: Start Development Server

Source: https://github.com/agenticsorg/devops/blob/main/README.md

Instructions to start the UI development server. Navigate to the 'ui' directory, install dependencies, and run the development script.

```bash
cd ui
npm install
npm run dev
```

--------------------------------

### Install Dependencies and Run Dev Server

Source: https://github.com/agenticsorg/devops/blob/main/ui/README.md

Standard commands to install project dependencies and start the development server using npm.

```sh
cd vibing

npm i

npm run dev
```

--------------------------------

### Clone Repository and Setup Virtual Environment

Source: https://github.com/agenticsorg/devops/blob/main/agentic_devops/README.md

Clone the repository and set up a Python virtual environment for development. Ensure you activate the environment before proceeding with installations.

```bash
git clone https://github.com/agentics-foundation/agentic-devops.git
cd agentic-devops

python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
```

--------------------------------

### Run CLI Examples

Source: https://github.com/agenticsorg/devops/blob/main/examples/README.md

Demonstrates how to use the Agentic DevOps CLI for various tasks like showing help, listing EC2 instances, getting GitHub repository details, and deploying from GitHub to EC2.

```bash
# Show main help
python run_cli.py --help
```

```bash
# Show EC2 commands
python run_cli.py ec2 --help
```

```bash
# List EC2 instances
python run_cli.py ec2 list-instances --output table
```

```bash
# Get GitHub repository details
python run_cli.py github get-repo owner/repo-name
```

```bash
# Deploy from GitHub to EC2
python run_cli.py deploy github-to-ec2 --repo owner/repo-name --instance-id i-1234567890abcdef0
```

--------------------------------

### Run Examples and CLI

Source: https://github.com/agenticsorg/devops/blob/main/docs/deployment/local-development.md

Execute example scripts or run the command-line interface tool.

```bash
python examples/hello_world.py
```

```bash
run_cli.py --help
```

--------------------------------

### Basic EC2 Agent Usage with OpenAI SDK

Source: https://github.com/agenticsorg/devops/blob/main/agentic_devops/README.md

Demonstrates how to initialize an EC2-focused agent, configure it with specific tools and instructions, and run a query using the Runner. This example requires the agents and agentic_devops libraries to be installed.

```python
from agents import Agent, Runner
from agentic_devops.agents.tools import (
    list_ec2_instances,
    start_ec2_instances,
    stop_ec2_instances,
    create_ec2_instance
)
from agentic_devops.core.context import DevOpsContext

# Create a context with user information
context = DevOpsContext(
    user_id="user123",
    aws_region="us-west-2",
    github_org="your-organization"
)

# Create an EC2-focused agent
ec2_agent = Agent(
    name="EC2 Assistant",
    instructions="""
    You are an EC2 management assistant that helps users manage their AWS EC2 instances.
    You can list, start, stop, and create EC2 instances based on user requests.
    Always confirm important actions before executing them and provide clear explanations.
    """,
    tools=[
        list_ec2_instances,
        start_ec2_instances,
        stop_ec2_instances,
        create_ec2_instance
    ],
    model="gpt-4o"
)

# Run the agent with a user query
result = Runner.run_sync(
    ec2_agent,
    "I need to launch 3 t2.micro instances for a web application in us-west-2. They should have the tag 'Project=WebApp'.",
    context=context
)

print(result.final_output)
```

--------------------------------

### Install Dependencies and Run FastAPI App

Source: https://github.com/agenticsorg/devops/blob/main/docs/deployment/llama-deployment.md

Install the necessary Python packages (FastAPI and Uvicorn) and run the FastAPI application using the command line.

```bash
pip install fastapi uvicorn
python app.py
```

--------------------------------

### Install Development Dependencies

Source: https://github.com/agenticsorg/devops/blob/main/agentic_devops/README.md

Install all necessary development dependencies using pip. This command should be run after activating the virtual environment.

```bash
pip install -r requirements-dev.txt
```

--------------------------------

### Install Project Dependencies

Source: https://github.com/agenticsorg/devops/blob/main/docs/deployment/local-development.md

Install project dependencies from the requirements file and install the package in editable mode.

```bash
pip install -r agentic_devops/requirements.txt
pip install -e agentic_devops
```

--------------------------------

### Install agentic-devops from Source

Source: https://github.com/agenticsorg/devops/blob/main/README.md

Clone the repository and install the package in editable mode for development.

```bash
git clone https://github.com/agenticsorg/devops.git
cd agentic-devops
pip install -e .
```

--------------------------------

### Environment Variables Setup

Source: https://github.com/agenticsorg/devops/blob/main/README.md

Configure your API keys and credentials by creating a .env file in your project directory.

```dotenv
OPENAI_API_KEY=your-openai-api-key
AWS_ACCESS_KEY_ID=your-aws-access-key
AWS_SECRET_ACCESS_KEY=your-aws-secret-key
AWS_REGION=us-east-1
GITHUB_TOKEN=your-github-token
```

--------------------------------

### Install Agentic DevOps Dependencies

Source: https://github.com/agenticsorg/devops/blob/main/agentic_devops/README.md

Clone the repository and install the necessary Python packages using pip. Ensure you have Python 3.8+ installed. After installation, copy the example environment file and edit it with your AWS, GitHub, and OpenAI credentials.

```bash
git clone https://github.com/agentics-foundation/agentic-devops.git
cd agentic-devops

pip install -r requirements.txt

cp env.example .env
# Edit .env with your AWS, GitHub, and OpenAI credentials
```

--------------------------------

### Install Serverless Framework

Source: https://github.com/agenticsorg/devops/blob/main/docs/deployment/aws-lambda.md

Installs the Serverless Framework globally using npm. This framework simplifies the deployment and management of serverless applications.

```bash
npm install -g serverless
```

--------------------------------

### Start EC2 Instances

Source: https://github.com/agenticsorg/devops/blob/main/docs/api/cli-commands.md

Starts one or more EC2 instances. Optionally waits for them to reach the running state.

```bash
agentic-devops ec2 start-instances --instance-ids INSTANCE_IDS [--region REGION] [--wait]
```

```bash
agentic-devops ec2 start-instances --instance-ids i-1234567890abcdef0,i-0987654321fedcba0 --region us-east-1 --wait
```

```bash
Successfully started instances: i-1234567890abcdef0, i-0987654321fedcba0
```

--------------------------------

### Deploy Application with Fly.io

Source: https://github.com/agenticsorg/devops/blob/main/ui/README.md

Instructions for deploying the application using Fly.io, including installing the CLI, logging in, and deploying.

```sh
# INSTALL FLY CLI IF NOT PRESENT
curl -L https://fly.io/install.sh | sh

# AUTHENTICATE
fly auth login

# DEPLOY
fly deploy
```

--------------------------------

### Install OpenAI Agents SDK

Source: https://github.com/agenticsorg/devops/blob/main/agentic_devops/plans/openai-agents-integration.md

Use pip to install the OpenAI Agents SDK. Ensure your environment is set up correctly before proceeding.

```bash
pip install openai-agents
```

--------------------------------

### Start EC2 Instances

Source: https://github.com/agenticsorg/devops/blob/main/docs/implementation/aws.md

Starts one or more specified EC2 instances in a given region.

```APIDOC
## start_ec2_instances

### Description
Starts specified EC2 instances.

### Parameters
#### Path Parameters
- **instance_ids** (List[str]) - Required - A list of instance IDs to start.
#### Query Parameters
- **region** (Optional[str]) - Optional - The AWS region where the instances are located.
```

--------------------------------

### Run Agent Examples

Source: https://github.com/agenticsorg/devops/blob/main/examples/README.md

Executes various Agentic DevOps examples using the OpenAI Agents SDK, including basic, CI/CD, disaster recovery, and security compliance workflows.

```bash
# Run the hello world example
python hello_world.py
```

```bash
# Run the basic DevOps agent example
python openai_agents_example.py
```

```bash
# Run the CI/CD pipeline agent example
python ci_cd_pipeline_agent.py
```

```bash
# Run the disaster recovery agent example
python disaster_recovery_agent.py
```

```bash
# Run the security compliance agent example
python security_compliance_agent.py
```

--------------------------------

### Configure Environment Variables

Source: https://github.com/agenticsorg/devops/blob/main/agentic_devops/docs/quickstart.md

Copy the example environment file and update it with your AWS and GitHub credentials. Ensure these are kept secure.

```bash
cp env.example .env
```

```dotenv
AWS_ACCESS_KEY_ID=your-access-key-id
AWS_SECRET_ACCESS_KEY=your-secret-access-key
AWS_REGION=us-east-1
GITHUB_TOKEN=your-github-personal-access-token
```

--------------------------------

### Start EC2 Instances

Source: https://github.com/agenticsorg/devops/blob/main/docs/api/aws-module.md

Starts one or more EC2 instances by their IDs. Optionally waits for the instances to reach the running state.

```APIDOC
## start_ec2_instances

### Description
Starts EC2 instances.

### Parameters
- **instance_ids** (List[str]) - Required - List of instance IDs.
- **region** (Optional[str]) - Optional - AWS region (default from config).
- **wait** (bool) - Optional - Wait for instances to start (default: True).
- **context** (Optional[DevOpsContext]) - Optional - DevOps context.

### Returns
- **List[EC2Instance]**: List of EC2Instance objects.
```

--------------------------------

### Create Lambda Deployment Package

Source: https://github.com/agenticsorg/devops/blob/main/docs/deployment/aws-lambda.md

Uses a Docker container to install Python dependencies into a `python/` directory and then creates a zip archive containing the handler file and installed dependencies. This package is ready for Lambda deployment.

```bash
docker run --rm -v $(pwd):/var/task agentic-devops-lambda \
  pip install -r requirements.txt -t python/ 
zip -r deployment-package.zip lambda_handler.py python/
```

--------------------------------

### Execute Agent Workflow with Runner

Source: https://github.com/agenticsorg/devops/blob/main/docs/implementation/openai-agents-integration.md

Example of using the Runner to execute an agent's workflow. This involves specifying the agent, the task, and the relevant context.

```python
# Example of running an agent
result = await Runner.run(
    agent,
    "Deploy the latest version of the application to production",
    context=devops_context
)
```

--------------------------------

### Build Documentation

Source: https://github.com/agenticsorg/devops/blob/main/docs/deployment/local-development.md

Build the project documentation using the make command.

```bash
cd docs && make html
```

--------------------------------

### Create API Dockerfile

Source: https://github.com/agenticsorg/devops/blob/main/docs/deployment/docker.md

Define the `Dockerfile.api` for the API service, specifying the base Python image, working directory, dependency installation, FastAPI/Uvicorn setup, code copying, and the command to run the API.

```dockerfile
FROM python:3.9-slim

WORKDIR /app

COPY agentic_devops/requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
RUN pip install fastapi uvicorn

COPY . .

ENV PYTHONPATH=/app

EXPOSE 8000

CMD ["uvicorn", "api.main:app", "--host", "0.0.0.0", "--port", "8000"]
```

--------------------------------

### Initialize GitHub Service and List Repositories

Source: https://github.com/agenticsorg/devops/blob/main/agentic_devops/services/github.md

Initializes the GitHub service with credentials and demonstrates listing repositories within a specified organization.

```python
# Initialize GitHub service
github_service = devops_agent.github.GitHubService(credentials)

# List repositories in an organization
repos = github_service.list_repositories(org='example-org')
```

--------------------------------

### Install agentic-devops from PyPI

Source: https://github.com/agenticsorg/devops/blob/main/README.md

Use this command to install the agentic-devops package using pip.

```bash
pip install agentic-devops
```

--------------------------------

### Initialize Agent with Web and File Search Tools

Source: https://github.com/agenticsorg/devops/blob/main/agentic_devops/docs/openai_agents_integration.md

Create an agent configured with WebSearchTool and FileSearchTool. Specify max results and vector store IDs for file search.

```python
from agents import Agent, WebSearchTool, FileSearchTool

agent = Agent(
    name="Research Agent",
    instructions="You are a research agent...",
    tools=[
        WebSearchTool(),
        FileSearchTool(
            max_num_results=3,
            vector_store_ids=["your-vector-store-id"],
        ),
    ],
    model="gpt-4o"
)
```

--------------------------------

### Install Python Dependencies

Source: https://github.com/agenticsorg/devops/blob/main/agentic_devops/docs/quickstart.md

Install all necessary Python packages for the DevOps Agent using the requirements file.

```bash
pip install -r requirements.txt
```

--------------------------------

### Initialize S3 Service and List Buckets

Source: https://github.com/agenticsorg/devops/blob/main/agentic_devops/services/s3.md

Initializes the S3 service with provided credentials and retrieves a list of all available S3 buckets.

```python
s3_service = devops_agent.aws.s3.S3Service(credentials)
buckets = s3_service.list_buckets()
```

--------------------------------

### Start EC2 Instance

Source: https://github.com/agenticsorg/devops/blob/main/docs/implementation/cli.md

Start a stopped EC2 instance by its ID. Optionally waits for the instance to be in a running state.

```bash
run_cli.py ec2 start-instance i-xxxxxxxxxxxxx --region us-west-2 --wait
```

--------------------------------

### Initialize IAM Service and List Users

Source: https://github.com/agenticsorg/devops/blob/main/agentic_devops/services/iam.md

Initializes the IAM service and demonstrates how to list all existing users.

```python
iam_service = devops_agent.aws.iam.IAMService(credentials)

# List all users
users = iam_service.list_users()
```

--------------------------------

### List All Configuration Values

Source: https://github.com/agenticsorg/devops/blob/main/docs/api/cli-commands.md

Display all currently set configuration values. This provides an overview of the system's configuration.

```bash
agentic-devops config list
```

--------------------------------

### Install Requirements for Agentic DevOps

Source: https://github.com/agenticsorg/devops/blob/main/examples/README.md

Installs all required dependencies for the Agentic DevOps framework if you encounter missing module errors.

```bash
pip install -r agentic_devops/requirements.txt
```

--------------------------------

### Install Dependencies for Llama Integration

Source: https://github.com/agenticsorg/devops/blob/main/docs/deployment/llama-deployment.md

Installs the necessary Python packages for Llama Index, OpenAI integration, and the Agentic DevOps framework.

```bash
pip install llama-index openai pydantic
pip install -e /path/to/agentic-devops
```

--------------------------------

### Create and Activate Virtual Environment

Source: https://github.com/agenticsorg/devops/blob/main/docs/deployment/local-development.md

Create a Python virtual environment and activate it for project dependencies. Use the appropriate command for your operating system.

```bash
python3 -m venv venv
source venv/bin/activate  # On Linux/macOS
```

```bash
venv\Scripts\activate  # On Windows
```

--------------------------------

### Initialize VPC Service and List VPCs

Source: https://github.com/agenticsorg/devops/blob/main/agentic_devops/services/vpc.md

Initializes the VPC service with credentials and retrieves a list of all VPCs in the AWS account.

```python
vpc_service = devops_agent.aws.vpc.VPCService(credentials)
vpcs = vpc_service.list_vpcs()
```

--------------------------------

### Setup Logging and Handle AWS Errors

Source: https://github.com/agenticsorg/devops/blob/main/agentic_devops/README.md

Configure logging with setup_logging and handle specific AWS errors like ResourceNotFoundError and general AWSServiceError, logging suggestions for remediation.

```python
from agentic_devops.core.logging import setup_logging
from agentic_devops.aws.base import AWSServiceError, ResourceNotFoundError

# Setup logging
logger = setup_logging(level="INFO", log_file="agentic-devops.log")

try:
    # Attempt to perform an operation
    ec2.start_instance(instance_id="i-nonexistentid")
except ResourceNotFoundError as e:
    # Handle specific error with context
    logger.error(f"Could not find instance: {e}")
    logger.info(f"Suggestion: {e.suggestion}")
    # Take remedial action
except AWSServiceError as e:
    # Handle general AWS errors
    logger.error(f"AWS operation failed: {e}")
    logger.info(f"Suggestion: {e.suggestion}")
```

--------------------------------

### Install Serverless Python Requirements Plugin

Source: https://github.com/agenticsorg/devops/blob/main/docs/deployment/aws-lambda.md

Installs the `serverless-python-requirements` plugin as a development dependency using npm. This plugin helps manage Python dependencies for Serverless Framework projects.

```bash
npm install --save-dev serverless-python-requirements
```

--------------------------------

### Build and Deploy with AWS SAM

Source: https://github.com/agenticsorg/devops/blob/main/docs/deployment/aws-lambda.md

Commands to build the serverless application locally using Docker and then deploy it to AWS using the SAM CLI. The `--guided` flag initiates an interactive deployment process.

```bash
sam build --use-container
sam deploy --guided
```

--------------------------------

### Install AWS SAM CLI

Source: https://github.com/agenticsorg/devops/blob/main/docs/deployment/aws-lambda.md

Installs the AWS Serverless Application Model Command Line Interface using pip. This tool is used for building and deploying serverless applications on AWS.

```bash
pip install aws-sam-cli
```

--------------------------------

### config get

Source: https://github.com/agenticsorg/devops/blob/main/docs/api/cli-commands.md

Retrieves a configuration value by its key.

```APIDOC
## config get

### Description
Retrieves a configuration value by its key.

### Command
```bash
agentic-devops config get --key KEY
```

### Parameters
#### Options
- `--key` (string) - Required - Configuration key

### Example
```bash
agentic-devops config get --key aws.region
```

### Response
```
aws.region = us-west-2
```
```

--------------------------------

### Multi-Stage Docker Build for Optimization

Source: https://github.com/agenticsorg/devops/blob/main/docs/deployment/docker.md

This example shows a multi-stage Docker build to reduce the final image size. It separates build dependencies from runtime requirements, ensuring a leaner production image.

```dockerfile
# Build stage
FROM python:3.9-slim AS builder

WORKDIR /app
COPY agentic_devops/requirements.txt .
RUN pip install --no-cache-dir --user -r requirements.txt

# Runtime stage
FROM python:3.9-slim

WORKDIR /app
COPY --from=builder /root/.local /root/.local
COPY . .

ENV PATH=/root/.local/bin:$PATH
ENV PYTHONPATH=/app

ENTRYPOINT ["python", "run_cli.py"]
```

--------------------------------

### Config Functions

Source: https://github.com/agenticsorg/devops/blob/main/docs/implementation/core.md

Provides functions for loading, getting, and setting configuration values.

```APIDOC
## Config Functions

### Description
Functions to manage the agent's configuration, including loading from files, retrieving specific values, and setting values programmatically.

### Functions
- `get_config()`: Retrieves the entire configuration object.
- `get_config_value(key: str)`: Retrieves a specific configuration value by key.
- `set_config_value(key: str, value: Any)`: Sets a configuration value.
- `load_config(path: str)`: Loads configuration from a file.
```

--------------------------------

### Clone Repository and Navigate

Source: https://github.com/agenticsorg/devops/blob/main/docs/deployment/local-development.md

Clone the Agentic DevOps repository and navigate into the project directory.

```bash
git clone <repository_url>
cd devops
```

--------------------------------

### Config Submodule Functions

Source: https://github.com/agenticsorg/devops/blob/main/docs/api/core-module.md

Functions for loading, getting, and setting configuration values.

```APIDOC
## Functions

- `load_config(config_file: Optional[str] = None, env_prefix: str = "DEVOPS", merge_defaults: bool = True) -> Dict[str, Any]`
- `get_config() -> Dict[str, Any]`
- `get_config_value(key_path: str, default: Any = None) -> Any`
- `set_config_value(key_path: str, value: Any) -> None`
```

--------------------------------

### Automated Deployment Workflow with OpenAI Agents

Source: https://github.com/agenticsorg/devops/blob/main/agentic_devops/plans/openai-agents-integration-strategy.md

Orchestrates a deployment workflow by chaining calls to GitHub and EC2 agents. This example demonstrates how to use the Runner to execute sequential agent tasks within a trace.

```python
# examples/openai_agents_deployment_example.py
from agents import Agent, Runner, Handoff, trace
import asyncio

# Assume github_agent and ec2_agent are defined elsewhere and imported
# For demonstration purposes, let's mock them here if they are not globally available
# In a real scenario, these would be imported from their respective modules

# Mock definitions for demonstration if not globally available
class MockAgent:
    def __init__(self, name):
        self.name = name

class MockRunner:
    @staticmethod
    async def run(agent, prompt, context=None):
        print(f"Running agent '{agent.name}' with prompt: '{prompt}'")
        # Simulate a result based on the prompt
        if "latest commit" in prompt:
            return type('obj', (object,), {'final_output': 'commit-sha-12345'})()
        elif "Deploy commit" in prompt:
            return type('obj', (object,), {'final_output': 'Deployment successful'})()
        else:
            return type('obj', (object,), {'final_output': 'Task completed'})()

# Replace with actual agent instances if available
github_agent = MockAgent("GitHub Agent")
ec2_agent = MockAgent("EC2 Agent")

# Use MockRunner if Runner is not available or for testing
# Runner = MockRunner

async def deploy_application():
    # Create a trace for the entire deployment workflow
    with trace("Deployment Workflow"):
        # Get the latest code from GitHub
        github_result = await Runner.run(
            github_agent,
            "Get the latest commit from the main branch of myorg/myapp"
        )
        
        # Deploy to EC2
        ec2_result = await Runner.run(
            ec2_agent,
            f"Deploy commit {github_result.final_output} to instance i-1234567890abcdef0"
        )
        
        print(f"Deployment result: {ec2_result.final_output}")

if __name__ == "__main__":
    import asyncio
    asyncio.run(deploy_application())

```

--------------------------------

### Get Repository README

Source: https://github.com/agenticsorg/devops/blob/main/agentic_devops/services/github.md

Retrieves the README content for a specific repository within an organization.

```python
# Get README for a specific repository
readme = github_service.get_readme(
    org='example-org',
    repo='example-repo'
)
```

--------------------------------

### CLI: Get GitHub Repository Info

Source: https://github.com/agenticsorg/devops/blob/main/README.md

Retrieve information about a GitHub repository using the CLI.

```bash
agentic-devops github get-repository --repo owner/repo
```

--------------------------------

### Create IAM User and Access Key

Source: https://github.com/agenticsorg/devops/blob/main/agentic_devops/services/iam.md

Shows how to create a new IAM user with specified path and tags, and then generate an access key for that user.

```python
# Create a new user
new_user = iam_service.create_user(
    user_name='john.doe',
    path='/developers/',
    tags=[{'Key': 'Department', 'Value': 'Engineering'}]
)

# Create an access key for the user
access_key = iam_service.create_access_key(user_name='john.doe')
```

--------------------------------

### CLI: Create EC2 Instance

Source: https://github.com/agenticsorg/devops/blob/main/agentic_devops/README.md

Create an EC2 instance using the CLI with detailed configuration including AMI, instance type, security groups, key pair, user data script, and tags. The `--wait` flag ensures the command blocks until the instance is ready.

```bash
agentic-devops ec2 create-instance \
  --name "web-server" \
  --type t3.medium \
  --ami-id ami-0c55b159cbfafe1f0 \
  --subnet-id subnet-1234567890abcdef0 \
  --security-group-ids sg-1234567890abcdef0 \
  --key-name my-key \
  --user-data-file startup-script.sh \
  --tags "Environment=Production,Project=Website" \
  --wait
```

--------------------------------

### Implement Tracing for Deployment Workflow

Source: https://github.com/agenticsorg/devops/blob/main/agentic_devops/plans/openai-agents-integration-strategy.md

Shows how to implement tracing for a deployment workflow using the 'trace' context manager. It includes steps for getting code from GitHub and deploying to EC2.

```python
from agents import trace

async def deploy_application():
    # Create a trace for the entire deployment workflow
    with trace("Deployment Workflow"):
        # Get the latest code from GitHub
        github_result = await Runner.run(
            github_agent,
            "Get the latest commit from the main branch"
        )
        
        # Deploy to EC2
        ec2_result = await Runner.run(
            ec2_agent,
            f"Deploy commit {github_result.final_output} to instance i-1234567890abcdef0"
        )
```

--------------------------------

### Get a Configuration Value

Source: https://github.com/agenticsorg/devops/blob/main/docs/api/cli-commands.md

Retrieve the value associated with a specific configuration key. This helps in verifying current settings.

```bash
agentic-devops config get --key KEY
```

```bash
agentic-devops config get --key aws.region
```

--------------------------------

### Deploy VPC Infrastructure from GitHub

Source: https://github.com/agenticsorg/devops/blob/main/agentic_devops/services/vpc.md

Deploys VPC infrastructure using a template stored in a GitHub repository. Provide the repository path, template file path, and any necessary parameters for the template.

```python
vpc_service.deploy_from_github(
    repository='example-org/network-templates',
    template_path='vpc/production.yaml',
    parameters={
        'EnvironmentName': 'Production',
        'VpcCidr': '10.0.0.0/16'
    }
)
```

--------------------------------

### Synchronous Agent Execution

Source: https://github.com/agenticsorg/devops/blob/main/agentic_devops/docs/openai_agents_integration.md

Run an agent synchronously to get immediate results. Ensure the 'agents' library is imported.

```python
from agents import Runner

result = Runner.run_sync(
    ec2_agent,
    "List all my EC2 instances in us-west-2 region",
    context={}
)

print(result.final_output)
```

--------------------------------

### Python API: Basic Usage

Source: https://github.com/agenticsorg/devops/blob/main/README.md

Demonstrates listing EC2 instances and getting repository information using the Python API. Ensure your environment is set up with necessary credentials.

```python
import asyncio
from agentic_devops.src.aws import list_ec2_instances
from agentic_devops.src.github import get_repository
from agentic_devops.src.core import DevOpsContext

async def main():
    # Create a context
    context = DevOpsContext(
        user_id="example-user",
        aws_region="us-east-1",
        github_org="example-org"
    )
    
    # List EC2 instances
    instances = await list_ec2_instances(region="us-east-1", context=context)
    print(f"Found {len(instances)} instances")
    
    # Get repository information
    repo = await get_repository(repo="example-org/example-repo", context=context)
    print(f"Repository: {repo.name}, Stars: {repo.stars}")

if __name__ == "__main__":
    asyncio.run(main())
```