Bytebot: Automate Tasks with Natural Language

bytebot-ai/bytebot

Think of Bytebot as a personal, AI-powered automation buddy for your desktop. Instead of writing complex scripts for repetitive tasks, you can simply tell it what you want to do in plain English. This is a game-changer for several reasons

Rapid Prototyping and Automation
Need to run a series of commands, move files, and open an application to test a new feature? Instead of creating a bash script, you can just describe the sequence. This speeds up the a-hoc tasks.

DevOps and CI/CD Integration
While it's a desktop agent, you can integrate it into your CI/CD pipelines to automate tasks that require a full desktop environment, such as GUI testing. You could have a pipeline step that uses Bytebot to navigate an application, click buttons, and report the results.

Accessibility and Usability
For engineers who aren't familiar with shell scripting or have repetitive, multi-step tasks that are a pain to automate, this makes it incredibly accessible. You can set up a "macro" with a simple phrase.

Cross-platform Tasks
Since it runs in a Docker container, you can run the same automation on any machine that supports Docker, ensuring consistent behavior across different environments (e.g., your laptop and a cloud server).

In essence, it takes the burden of low-level scripting away, allowing you to focus on the more complex engineering problems.

Getting started with Bytebot is a straightforward process thanks to its containerized nature. You'll need Docker installed on your machine.

Step 1
Clone the Repository First, you'll need to grab the source code from the project's repository. Open your terminal and run

git clone https://github.com/bytebot-ai/bytebot.git
cd bytebot

Step 2
Build the Docker Image Next, you'll build the Docker image. This process might take a few minutes as it downloads all the necessary dependencies.

docker build -t bytebot-agent .

Step 3
Run the Agent After the image is built, you can run the agent. This command starts the container and maps the necessary ports. The -e OPENAI_API_KEY=your_key part is crucial as it provides the AI model's API key.

docker run -it --rm \
    --name bytebot-agent \
    -e OPENAI_API_KEY=your_api_key \
    -p 5000:5000 \
    bytebot-agent

Once the container is running, the agent's web interface will be available at http://localhost:5000. This is where you'll interact with the agent via natural language.

While most of the interaction is through the web interface, you can also interact with it programmatically. For example, you can use curl or a Python script to send commands to the running container's API.

Example 1
Using curl to Automate a Simple Task Let's say you want to automate the task of opening a web browser to a specific URL and then a text editor. You could do this by sending a command to the agent's API.

# This is a conceptual example, as the exact API endpoint may vary.
curl -X POST http://localhost:5000/api/command \
-H "Content-Type: application/json" \
-d '{
    "task": "Open Google Chrome and navigate to https://github.com, then open VS Code."
}'

Example 2
A Python Script for a Development Workflow You can integrate this into a larger script for a more complex workflow. Here's a Python example that could be part of your Makefile or dev_setup.py script.

import requests
import json
import time

def run_bytebot_task(task_description):
    url = "http://localhost:5000/api/command" # The API endpoint
    headers = {"Content-Type": "application/json"}
    payload = {"task": task_description}
    
    try:
        response = requests.post(url, headers=headers, data=json.dumps(payload))
        response.raise_for_status() # Raise an exception for bad status codes
        print(f"Task sent successfully: {task_description}")
        print("Response:", response.json())
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Error sending task: {e}")
        return None

# A sample development workflow
if __name__ == "__main__":
    print("Starting development environment setup...")
    
    # Task 1: Open a terminal and run a dev server
    run_bytebot_task("Open a new terminal, navigate to the `my-project` directory, and run `npm run dev`.")
    
    # Give the server a moment to start
    time.sleep(10) 
    
    # Task 2: Open a browser to the running application
    run_bytebot_task("Open a new Google Chrome window and navigate to http://localhost:3000.")
    
    # Task 3: Open the project in VS Code
    run_bytebot_task("Open the `my-project` folder in Visual Studio Code.")
    
    print("Development environment is now set up! Happy coding! ")