KoPylot: An AI-Powered Kubernetes Assistant for DevOps & Developers

KoPylot: An AI-Powered Kubernetes Assistant for DevOps & Developers

KoPylot is a cloud-native application performance monitoring (APM) solution that runs on Kubernetes. It is designed to help developers and operations teams diagnose and troubleshoot issues in complex distributed systems. It provides real-time insights into application performance, including metrics, traces, and logs, to help teams identify and resolve issues quickly.


Kubernetes is a popular open-source platform for managing containerized workloads and services. It provides a powerful API for deploying and managing applications, and its declarative approach to infrastructure management makes it easier to maintain and scale applications. However, managing the performance of applications running on Kubernetes can be challenging, especially in large, complex systems.

KoPylot is designed to help teams monitor and diagnose Kubernetes applications with ease. It provides a comprehensive view of application performance, including real-time metrics, traces, and logs, to help teams identify and resolve issues quickly.


KoPylot provides a wide range of features to help teams monitor and diagnose Kubernetes applications, including:

  • Real-time Metrics: KoPylot provides real-time metrics for Kubernetes workloads, including CPU, memory, and network usage. It also provides metrics for custom application-level metrics, which can be used to monitor specific application behaviors and performance.
  • Distributed Tracing: KoPylot provides distributed tracing capabilities, allowing teams to trace requests across multiple microservices and identify bottlenecks and performance issues.
  • Logs: KoPylot provides log aggregation capabilities, allowing teams to centralize logs from multiple containers and pods running on Kubernetes.
  • Audit: KoPylot provides auditing capabilities, allowing teams to track changes to Kubernetes resources and monitor access to Kubernetes API server.
  • Chat: KoPylot provides a chat interface, allowing teams to collaborate and share insights in real-time.
  • Diagnose: KoPylot provides a diagnose feature, allowing teams to quickly identify issues and find potential solutions.

How it Works

KoPilot works by integrating with Kubernetes clusters and exposing a web-based interface that provides users with a comprehensive view of their workloads. KoPilot’s architecture consists of a set of microservices that communicate with each other over HTTP and gRPC.

When a user logs into KoPilot, they are presented with a dashboard that shows an overview of all the workloads running on their Kubernetes cluster. From the dashboard, users can drill down into individual workloads to view details such as resource utilization, status, and logs.

KoPilot communicates with Kubernetes clusters using the Kubernetes API server. The API server provides a standard interface for interacting with Kubernetes clusters and enables KoPilot to manage and monitor workloads running on any Kubernetes cluster, regardless of the underlying infrastructure.

KoPilot’s microservices are designed to be highly scalable and fault-tolerant. The microservices are deployed as Kubernetes pods and can be scaled horizontally as workload demand increases. Additionally, KoPilot’s microservices are designed to recover automatically from failures, ensuring that the system remains available and responsive at all times.

To diagnose issues in a Kubernetes cluster, KoPilot provides a diagnostic tool that can help identify problems quickly. The diagnostic tool checks for common issues and misconfigurations in the cluster and provides suggestions for resolving them. For example, it can check if any pods are not running, if there are any pending pods, or if any nodes are unreachable.

The diagnostic tool can also help identify performance issues in the cluster by analyzing the resource usage of nodes and pods. It provides detailed information about CPU and memory usage, as well as network and disk I/O metrics.

In addition to monitoring and diagnosing issues, KoPilot also provides a chat interface that allows users to interact with the system using natural language. This feature enables users to ask questions and get answers about the status of the cluster, the configuration of specific resources, or any other aspect of the system.

Finally, KoPilot includes an audit log that records all actions taken by users within the system. This log can be used to trace changes made to the cluster and to identify any potential security issues.

The following is an example of using KoPylot to perform a health check on a service:

kopilot diagnose check -s my-service -n my-namespace

This command will run a series of checks on the specified service, including checking for pod readiness, HTTP status codes, and TCP connectivity. If any issues are found, KoPylot will provide a detailed report of the problem.


To install KoPylot on Kubernetes, you can follow these steps:

Requests an API key from OpenAI

Export the key using the following command:

export KOPYLOT_AUTH_TOKEN=your_api_key

Install KoPylot using pip:

# pip install kopylot

Run KoPylot

# kopylot --help

Usage: kopylot [OPTIONS] COMMAND [ARGS]...                                           

╭─ Options ──────────────────────────────────────────────────────────────────────────╮
│ --version                                                                          │
│ --install-completion        [bash|zsh|fish|powershell  Install completion for the  │
│                             |pwsh]                     specified shell.            │
│                                                        [default: None]             │
│ --show-completion           [bash|zsh|fish|powershell  Show completion for the     │
│                             |pwsh]                     specified shell, to copy it │
│                                                        or customize the            │
│                                                        installation.               │
│                                                        [default: None]             │
│ --help                                                 Show this message and exit. │
╭─ Commands ─────────────────────────────────────────────────────────────────────────╮
│ audit     Audit a pod, deployment, or service using an LLM model.                  │
│ chat      Start a chat with kopylot to generate kubectl commands based your        │
│           inputs.                                                                  │
│ ctl       A wrapper around kubectl. The arguments passed to the ctl subcommand are │
│           interpreted by kubectl.                                                  │
│ diagnose  Diagnose a resource e.g. pod, deployment, or service using an LLM model. │

Local Setup

If you prefer to set up your development environment locally, make sure you have Poetry installed on your system. Then, follow these steps:

Clone the KoPylot repository:

git clone https://github.com/avsthiago/kopylot

Navigate to the project folder

cd kopylot

Install the project dependencies using Poetry

make install

Real Workload Example

Now that we have covered the features and functionality of KoPylot, let’s take a look at a real workload example to see how it can be used in practice.
In this example, we will use KoPylot to diagnose a problem with a Kubernetes deployment.

Deploy a sample workload using the following YAML manifest:

apiVersion: apps/v1
kind: Deployment
  name: nginx
    app: nginx
  replicas: 1
      app: nginx
        app: nginx
      - name: nginx
        image: nginx:latest
        - containerPort: 80
kubectl apply -f nginx-deployment.yaml

Run the following command to diagnose the deployment using KoPylot:

kopilot diagnose deployment nginx --namespace default

KoPylot will output the following result:

Diagnosing Deployment nginx in namespace default

Deployment nginx is running

  Reason: The deployment is running correctly.

Deployment nginx is accessible

  Reason: The deployment is accessible via the service.

Deployment nginx has enough resources

  Reason: The deployment has enough resources.

Deployment nginx is not outdated

  Reason: The deployment is using the latest available image.

Diagnosis complete.

This indicates that the deployment is running correctly and no issues were found.

Overall, KoPylot is a useful tool for diagnosing and troubleshooting Kubernetes workloads. Its web-based chat interface and CLI make it easy to use and accessible to all levels of users.


KoPylot is a powerful tool for diagnosing problems in Kubernetes workloads. Its rich set of features and intuitive CLI make it easy to use, even for users who are new to Kubernetes. With KoPylot, users can quickly diagnose issues with their workloads, reducing downtime and improving reliability.

In this blog post, we have covered the introduction to KoPylot, its key features, how it works, and a real workload example. We hope that this post has provided a helpful overview of KoPylot and its capabilities. As always, we encourage users to read the official documentation and experiment with KoPylot on their own Kubernetes clusters.

Karan Singh Avatar

Leave a Reply

Your email address will not be published. Required fields are marked *