holmesgpt
On-Call/DevOps Assistant - Get a head start on fixing alerts with AI investigation
Stars: 397
HolmesGPT is an open-source DevOps assistant powered by OpenAI or any tool-calling LLM of your choice. It helps in troubleshooting Kubernetes, incident response, ticket management, automated investigation, and runbook automation in plain English. The tool connects to existing observability data, is compliance-friendly, provides transparent results, supports extensible data sources, runbook automation, and integrates with existing workflows. Users can install HolmesGPT using Brew, prebuilt Docker container, Python Poetry, or Docker. The tool requires an API key for functioning and supports OpenAI, Azure AI, and self-hosted LLMs.
README:
The only AI assistant that investigates incidents like a human does - by looking at alerts and fetching missing data until it finds the root cause. Powered by OpenAI, Azure AI, AWS Bedrock, or any tool-calling LLM of your choice, including open source models.
- Investigate Incidents (AIOps) from PagerDuty/OpsGenie/Prometheus/Jira/more
- Bidirectional Integrations see investigation results inside your existing ticketing/incident management system
- Automated Triage: Use HolmesGPT as a first responder. Flag critical alerts and prioritize them for your team to look at
- Alert Enrichment: Automatically add context to alerts - like logs and microservice health info - to find root causes faster
- Identify Cloud Problems by asking HolmesGPT questions about unhealthy infrastructure
- Runbook Automation in Plain English: Speed up your response to known issues by investigating according to runbooks you provide
Kubernetes Troubleshooting
holmes ask "what pods are unhealthy in my cluster and why?"
Prometheus Alert RCA (root cause analysis)
Investigate Prometheus alerts right from Slack with the official Robusta integration.
Or run HolmesGPT from the cli:
kubectl port-forward alertmanager-robusta-kube-prometheus-st-alertmanager-0 9093:9093 &
holmes investigate alertmanager --alertmanager-url http://localhost:9093
Note - if on Mac OS and using the Docker image, you will need to use http://docker.for.mac.localhost:9093
instead of http://localhost:9093
Log File Analysis
Attach files to the HolmesGPT session with -f
:
sudo dmesg > dmesg.log
poetry run python3 holmes.py ask "investigate errors in this dmesg log" -f dmesg.log
Jira Ticket Investigation
holmes investigate jira --jira-url https://<PLACEDHOLDER>.atlassian.net --jira-username <PLACEHOLDER_EMAIL> --jira-api-key <PLACEHOLDER_API_KEY>
By default results are displayed in the CLI . Use --update
to get the results as a comment in the Jira ticket.
GitHub Issue Investigation
holmes investigate github --github-url https://<PLACEHOLDER> --github-owner <PLACEHOLDER_OWNER_NAME> --github-repository <PLACEHOLDER_GITHUB_REPOSITORY> --github-pat <PLACEHOLDER_GITHUB_PAT>
By default results are displayed in the CLI. Use --update
to get the results as a comment in the GitHub issue.
OpsGenie Alert Investigation
holmes investigate opsgenie --opsgenie-api-key <PLACEHOLDER_APIKEY>
By default results are displayed in the CLI . Use --update --opsgenie-team-integration-key <PLACEHOLDER_TEAM_KEY>
to get the results as a comment in the OpsGenie alerts. Refer to the CLI help for more info.
PagerDuty Incident Investigation
holmes investigate pagerduty --pagerduty-api-key <PLACEHOLDER_APIKEY>
By default results are displayed in the CLI. Use --update --pagerduty-user-email <PLACEHOLDER_EMAIL>
to get the results as a comment in the PagerDuty issue. Refer to the CLI help for more info.
K9s Plugin
You can add HolmesGPT as a plugin for K9s to investigate why any Kubernetes resource is unhealthy.
Add the following contents to the K9s plugin file, typically ~/.config/k9s/plugins.yaml
on Linux and ~/Library/Application Support/k9s/plugins.yaml
on Mac. Read more about K9s plugins here and check your plugin path here.
Note: HolmesGPT must be installed and configured for the K9s plugin to work.
Basic plugin to run an investigation on any Kubernetes object, using the shortcut Shift + H
:
plugins:
holmesgpt:
shortCut: Shift-H
description: Ask HolmesGPT
scopes:
- all
command: bash
background: false
confirm: false
args:
- -c
- |
holmes ask "why is $NAME of $RESOURCE_NAME in -n $NAMESPACE not working as expected"
echo "Press 'q' to exit"
while : ; do
read -n 1 k <&1
if [[ $k = q ]] ; then
break
fi
done
Advanced plugin that lets you modify the questions HolmesGPT asks about the LLM, using the shortcut Shift + O
. (E.g. you can change the question to "generate an HPA for this deployment" and the AI will follow those instructions and output an HPA configuration.)
plugins:
custom-holmesgpt:
shortCut: Shift-Q
description: Custom HolmesGPT Ask
scopes:
- all
command: bash
background: false
confirm: false
args:
- -c
- |
INSTRUCTIONS="# Edit the line below. Lines starting with '#' will be ignored."
DEFAULT_ASK_COMMAND="why is $NAME of $RESOURCE_NAME in -n $NAMESPACE not working as expected"
QUESTION_FILE=$(mktemp)
echo "$INSTRUCTIONS" > "$QUESTION_FILE"
echo "$DEFAULT_ASK_COMMAND" >> "$QUESTION_FILE"
# Open the line in the default text editor
${EDITOR:-nano} "$QUESTION_FILE"
# Read the modified line, ignoring lines starting with '#'
user_input=$(grep -v '^#' "$QUESTION_FILE")
echo running: holmes ask "\"$user_input\""
holmes ask "$user_input"
echo "Press 'q' to exit"
while : ; do
read -n 1 k <&1
if [[ $k = q ]] ; then
break
fi
done
Like what you see? Checkout other use cases or get started by installing HolmesGPT.
- Connects to Existing Observability Data: Find correlations you didn’t know about. No need to gather new data or add instrumentation.
- Compliance Friendly: Can be run on-premise with your own LLM (or in the cloud with OpenAI/Azure/AWS)
- Transparent Results: See a log of the AI’s actions and what data it gathered to understand how it reached conclusions
- Extensible Data Sources: Connect the AI to custom data by providing your own tool definitions
- Runbook Automation: Optionally provide runbooks in plain English and the AI will follow them automatically
- Integrates with Existing Workflows: Connect Slack and Jira to get results inside your existing tools
Prerequisite: Get an API key for a supported LLM.
Installation Methods:
Brew (Mac/Linux)
- Add our tap:
brew tap robusta-dev/homebrew-holmesgpt
- Install holmesgpt:
brew install holmesgpt
- Check that installation was successful. This will take a few seconds on the first run - wait patiently.:
holmes --help
- Run holmesgpt:
holmes ask "what issues do I have in my cluster"
Prebuilt Docker Container
Run the prebuilt Docker container docker.pkg.dev/genuine-flight-317411/devel/holmes
, with extra flags to mount relevant config files (so that kubectl and other tools can access AWS/GCP resources using your local machine's credentials)
docker run -it --net=host -v ~/.holmes:/root/.holmes -v ~/.aws:/root/.aws -v ~/.config/gcloud:/root/.config/gcloud -v $HOME/.kube/config:/root/.kube/config us-central1-docker.pkg.dev/genuine-flight-317411/devel/holmes ask "what pods are unhealthy and why?"
Cutting Edge (Pip and Pipx)
You can install HolmesGPT from the latest git version with pip or pipx.
We recommend using pipx because it guarantees that HolmesGPT is isolated from other python packages on your system, preventing dependency conflicts.
First Pipx (skip this step if you are using pip).
Then install HolmesGPT from git with either pip or pipx:
pipx install "https://github.com/robusta-dev/holmesgpt/archive/refs/heads/master.zip"
Verify that HolmesGPT was installed by checking the version:
holmes version
To upgrade HolmesGPT with pipx, you can run:
pipx upgrade holmesgpt
From Source (Python Poetry)
First install poetry (the python package manager)
git clone https://github.com/robusta-dev/holmesgpt.git
cd holmesgpt
poetry install --no-root
poetry run python3 holmes.py ask "what pods are unhealthy and why?"
From Source (Docker)
Clone the project from github, and then run:
cd holmesgpt
docker build -t holmes . -f Dockerfile.dev
docker run -it --net=host -v -v ~/.holmes:/root/.holmes -v ~/.aws:/root/.aws -v ~/.config/gcloud:/root/.config/gcloud -v $HOME/.kube/config:/root/.kube/config holmes ask "what pods are unhealthy and why?"
Run HolmesGPT in your cluster (Helm)
Most users should install Holmes using the instructions in the Robusta docs ↗ and NOT the below instructions.
By using the Robusta
integration you’ll benefit from an end-to-end integration that integrates with Prometheus alerts
and Slack
. Using the below instructions you’ll have to build many of those components yourself.
In this mode, all the parameters should be passed to the HolmesGPT deployment, using environment variables.
We recommend pulling sensitive variables from Kubernetes secrets
.
First, you'll need to create your holmes-values.yaml
file, for example:
additionalEnvVars:
- name: MODEL
value: gpt-4o
- name: OPENAI_API_KEY
value: <your open ai key>
Then, install with helm
;
helm repo add robusta https://robusta-charts.storage.googleapis.com && helm repo update
helm install holmes robusta/holmes -f holmes-values.yaml
For all LLMs you need to provide the MODEL
environment variable, which specifies which model you are using.
Some LLMs requires additional variables:
OpenAI
For OpenAI, only the model
and api-key
should be provided
additionalEnvVars:
- name: MODEL
value: gpt-4o
- name: OPENAI_API_KEY
valueFrom:
secretKeyRef:
name: my-holmes-secret
key: openAiKey
Note: gpt-4o
is optional since it's default model.
Azure OpenAI
To work with Azure AI, you need to provide the below variables:
additionalEnvVars:
- name: MODEL
value: azure/my-azure-deployment # your azure deployment name
- name: AZURE_API_VERSION
value: 2024-02-15-preview # azure openai api version
- name: AZURE_API_BASE
value: https://my-org.openai.azure.com/ # base azure openai url
- name: AZURE_API_KEY
valueFrom:
secretKeyRef:
name: my-holmes-secret
key: azureOpenAiKey
AWS Bedrock
enablePostProcessing: true
additionalEnvVars:
- name: MODEL
value: bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0
- name: AWS_REGION_NAME
value: us-east-1
- name: AWS_ACCESS_KEY_ID
valueFrom:
secretKeyRef:
name: my-holmes-secret
key: awsAccessKeyId
- name: AWS_SECRET_ACCESS_KEY
valueFrom:
secretKeyRef:
name: my-holmes-secret
key: awsSecretAccessKey
Note: bedrock claude
provides better results when using post-processing to summarize the results.
Trusting custom Certificate Authority (CA) certificate:
If your llm provider url uses a certificate from a custom CA, in order to trust it, base-64 encode the certificate, and store it in an environment variable named CERTIFICATE
HolmesGPT requires an LLM API Key to function. The most common option is OpenAI, but many LiteLLM-compatible models are supported. To use an LLM, set --model
(e.g. gpt-4o
or bedrock/anthropic.claude-3-5-sonnet-20240620-v1:0
) and --api-key
(if necessary). Depending on the provider, you may need to set environment variables too.
Instructions for popular LLMs:
OpenAI
To work with OpenAI’s GPT 3.5 or GPT-4 models you need a paid OpenAI API key.
Note: This is different from being a “ChatGPT Plus” subscriber.
Pass your API key to holmes with the --api-key
cli argument. Because OpenAI is the default LLM, the --model
flag is optional for OpenAI (gpt-4o is the default).
holmes ask --api-key="..." "what pods are crashing in my cluster and why?"
If you prefer not to pass secrets on the cli, set the OPENAI_API_KEY environment variable or save the API key in a HolmesGPT config file.
Azure OpenAI
To work with Azure AI, you need an Azure OpenAI resource and to set the following environment variables:
- AZURE_API_VERSION - e.g. 2024-02-15-preview
- AZURE_API_BASE - e.g. https://my-org.openai.azure.com/
- AZURE_API_KEY (optional) - equivalent to the
--api-key
cli argument
Set those environment variables and run:
holmes ask "what pods are unhealthy and why?" --model=azure/<DEPLOYMENT_NAME> --api-key=<API_KEY>
Refer LiteLLM Azure docs ↗ for more details.
AWS Bedrock
Before running the below command you must run pip install boto3>=1.28.57
and set the following environment variables:
AWS_REGION_NAME
AWS_ACCESS_KEY_ID
AWS_SECRET_ACCESS_KEY
If the AWS cli is already configured on your machine, you may be able to find those parameters with:
cat ~/.aws/credentials ~/.aws/config
Once everything is configured, run:
holmes ask "what pods are unhealthy and why?" --model=bedrock/<MODEL_NAME>
Be sure to replace MODEL_NAME
with a model you have access to - e.g. anthropic.claude-3-5-sonnet-20240620-v1:0
. To list models your account can access:
aws bedrock list-foundation-models --region=us-east-1
Note that different models are available in different regions. For example, Claude Opus is only available in us-west-2.
Refer to LiteLLM Bedrock docs ↗ for more details.
Using Ollama
Ollama is supported, but buggy. We recommend using other models if you can, until Ollama tool-calling capabilities improve. Specifically, Ollama often calls tools with non-existent or missing parameters.If you'd like to try using Ollama anyway, see below:
export OLLAMA_API_BASE="http://localhost:11434"
holmes ask "what pods are unhealthy in my cluster?" --model="ollama_chat/llama3.1"
You can also connect to Ollama in the standard OpenAI format (this should be equivalent to the above):
# note the v1 at the end
export OPENAI_API_BASE="http://localhost:11434/v1"
# holmes requires OPENAPI_API_KEY to be set but value does not matter
export OPENAI_API_KEY=123
holmes ask "what pods are unhealthy in my cluster?" --model="openai/llama3.1"
Using other OpenAI-compatible models
You will need an LLM with support for function-calling (tool-calling).
- Set the environment variable for your URL with
OPENAI_API_BASE
- Set the model as
openai/<your-model-name>
(e.g.,llama3.1:latest
) - Set your API key (if your URL doesn't require a key, then add a random value for
--api-key
)
export OPENAI_API_BASE=<URL_HERE>
holmes ask "what pods are unhealthy and why?" --model=openai/<MODEL_NAME> --api-key=<API_KEY_HERE>
Important: Please verify that your model and inference server support function calling! HolmesGPT is currently unable to check if the LLM it was given supports function-calling or not. Some models that lack function-calling capabilities will hallucinate answers instead of reporting that they are unable to call functions. This behaviour depends on the model.
In particular, note that vLLM does not yet support function calling, whereas llama-cpp does support it.
Confluence
HolmesGPT can read runbooks from Confluence. To give it access, set the following environment variables:- CONFLUENCE_BASE_URL - e.g. https://robusta-dev-test.atlassian.net
- CONFLUENCE_USER - e.g. [email protected]
- CONFLUENCE_API_KEY - refer to Atlassian docs on generating API keys
Jira, GitHub, OpsGenie, PagerDuty, and AlertManager
HolmesGPT can pull tickets/alerts from each of these sources and investigate them.
Refer to holmes investigate jira --help
etc for details, or view the examples.
HolmesGPT was designed for incident response, but it is a general DevOps assistant too. Here are some examples:
Ask Questions About Your Cloud
holmes ask "what services does my cluster expose externally?"
Ticket Management - Automatically Respond to Jira tickets related to DevOps tasks
holmes investigate jira --jira-url https://<PLACEDHOLDER>.atlassian.net --jira-username <PLACEHOLDER_EMAIL> --jira-api-key <PLACEHOLDER_API_KEY>
Find the right configuration to change in big Helm charts
LLM uses the built-in Helm toolset to gather information.
holmes ask "what helm value should I change to increase memory request of the my-argo-cd-argocd-server-6864949974-lzp6m pod"
Optimize Docker container size
LLM uses the built-in Docker toolset to gather information.
holmes ask "Tell me what layers of my pavangudiwada/robusta-ai docker image consume the most storage and suggest some fixes to it"
HolmesGPT can investigate many issues out of the box, with no customization or training.
That said, we provide several extension points for teaching HolmesGPT to investigate your issues, according to your best practices. The two main extension points are:
- Custom Tools - give HolmesGPT access to data that it can't otherwise access - e.g. traces, APM data, or custom APIs
- Custom Runbooks - give HolmesGPT instructions for investigating specific issues it otherwise wouldn't know how to handle
Add Custom Tools
The more data you give HolmesGPT, the better it will perform. Give it access to more data by adding custom tools.
New tools are loaded using -t
from custom toolset files or by adding them to the ~/.holmes/config.yaml
with the setting custom_toolsets: ["/path/to/toolset.yaml"]
.
Add Custom Runbooks
HolmesGPT can investigate by following runbooks written in plain English. Add your own runbooks to provided the LLM specific instructions.
New runbooks are loaded using -r
from custom runbook files or by adding them to the ~/.holmes/config.yaml
with the custom_runbooks: ["/path/to/runbook.yaml"]
.
Reading settings from a config file
You can customize HolmesGPT's behaviour with command line flags, or you can save common settings in config file for re-use.
You can view an example config file with all available settings here.
By default, without specifying --config
the agent will try to read ~/.holmes/config.yaml
. When settings are present in both config file and cli, the cli option takes precedence.
Custom Toolsets
You can define your own custom toolsets to extend the functionality of your setup. These toolsets can include querying company-specific data, fetching logs from observability tools, and more.
# Add paths to your custom toolsets here
# Example: ["path/to/your/custom_toolset.yaml"]
#custom_toolsets: ["examples/custom_toolset.yaml"]
Alertmanager Configuration
Configure the URL for your Alertmanager instance to enable alert management and notifications.
# URL for the Alertmanager
#alertmanager_url: "http://localhost:9093"
Jira Integration
Integrate with Jira to automate issue tracking and project management tasks. Provide your Jira credentials and specify the query to fetch issues and optionally update their status.
# Jira credentials and query settings
#jira_username: "[email protected]"
#jira_api_key: "..."
#jira_url: "https://your-company.atlassian.net"
#jira_query: "project = 'Natan Test Project' and Status = 'To Do'"
-
jira_username: The email you use to log into your Jira account. Eg:
[email protected]
- jira_api_key: Follow these instructions to get your API key.
- jira_url: The URL of your workspace. For example: https://workspace.atlassian.net (Note: schema (https) is required)
- project: Name of the project you want the Jira tickets to be created in. Go to Project Settings -> Details -> Name.
-
status: Status of a ticket. Example:
To Do
,In Progress
GitHub Integration
Integrate with GitHub to automate issue tracking and project management tasks. Provide your GitHub PAT (personal access token) and specify the owner/repository
.
# GitHub credentials and query settings
#github_owner: "robusta-dev"
#github_pat: "..."
#github_url: "https://api.github.com" (default)
#github_repository: "holmesgpt"
#github_query: "is:issue is:open"
-
github_owner: The repository owner. Eg:
robusta-dev
- github_pat: Follow these instructions to get your GitHub pat (personal access token).
- github_url: The URL of your GitHub API. For example: https://api.github.com (Note: schema (https) is required)
-
github_repository: Name of the repository you want the GitHub issues to be scanned. Eg:
holmesgpt
.
PagerDuty Integration
Integrate with PagerDuty to automate incident tracking and project management tasks. Provide your PagerDuty credentials and specify the user email to update the incident with findings.
pagerduty_api_key: "..."
pagerduty_user_email: "[email protected]"
pagerduty_incident_key: "..."
- pagerduty_api_key: The PagerDuty API key. This can be found in the PagerDuty UI under Integrations > API Access Key.
- pagerduty_user_email: When --update is set, which user will be listed as the user who updated the incident. (Must be the email of a valid user in your PagerDuty account.)
- pagerduty_incident_key: If provided, only analyze a single PagerDuty incident matching this key
OpsGenie Integration
Integrate with OpsGenie to automate alert investigations. Provide your OpsGenie credentials and specify the query to fetch alerts.
opsgenie_api_key : "..."
opsgenie-team-integration-key: "...."
opsgenie-query: "..."
- opsgenie_api_key: The OpsGenie API key. Get it from Settings > API key management > Add new API key
- opsgenie-team-integration-key: OpsGenie Team Integration key for writing back results. (NOT a normal API Key.) Get it from Teams > YourTeamName > Integrations > Add Integration > API Key. Don't forget to turn on the integration and add the Team as Responders to the alert.
- opsgenie-query: E.g. 'message: Foo' (see https://support.atlassian.com/opsgenie/docs/search-queries-for-alerts/)
Slack Integration
Configure Slack to send notifications to specific channels. Provide your Slack token and the desired channel for notifications.
# Slack token and channel configuration
#slack_token: "..."
#slack_channel: "#general"
-
slack-token: The Slack API key. You can generate with
pip install robusta-cli && robusta integrations slack
- slack-channel: The Slack channel where you want to receive the findings.
Custom Runbooks
Define custom runbooks to give explicit instructions to the LLM on how to investigate certain alerts. This can help in achieving better results for known alerts.
# Add paths to your custom runbooks here
# Example: ["path/to/your/custom_runbook.yaml"]
#custom_runbooks: ["examples/custom_runbooks.yaml"]
Choose between OpenAI, Azure, AWS Bedrock, and more. Provide the necessary API keys and endpoints for the selected service.
OpenAI
# Configuration for OpenAI LLM
#api_key: "your-secret-api-key"
Azure
# Configuration for Azure LLM
#api_key: "your-secret-api-key"
#model: "azure/<DEPLOYMENT_NAME>"
#you will also need to set environment variables - see above
Bedrock
# Configuration for AWS Bedrock LLM
#model: "bedrock/<MODEL_ID>"
#you will also need to set environment variables - see above
Distributed under the MIT License. See LICENSE.txt for more information.
If you have any questions, feel free to message us on robustacommunity.slack.com
To contribute to HolmesGPT, first follow the Installation instructions for running HolmesGPT from source using Poetry. Then follow an appropriate guide below, or ask us for help on Slack
Adding new runbooks
You can contribute knowledge on solving common alerts and HolmesGPT will use this knowledge to solve related issues. To do so, add a new file to ./holmes/plugins/runbooks - or edit an existing runbooks file in that same directory.
Note: if you prefer to keep your runbooks private, you can store them locally and pass them to HolmesGPT with the -r
flag. However, if your runbooks relate to common problems that others may encounter, please consider opening a PR and making HolmesGPT better for everyone!
Adding new toolsets
You can add define new tools in YAML and HolmesGPT will use those tools in it's investigation. To do so, add a new file to ./holmes/plugins/toolsets - or edit an existing toolsets file in that same directory.
Note: if you prefer to keep your tools private, you can store them locally and pass them to HolmesGPT with the -t
flag. However, please consider contributing your toolsets! At least one other community member will probably find them useful!
Modifying the default prompts (prompt engineering)
The default prompts for HolmesGPT are located in ./holmes/plugins/prompts. Most holmes
commands accept a --system-prompt
flag that you can use to override this.
If you find a scenario where the default prompts don't work, please consider letting us know by opening a GitHub issue or messaging us on Slack! We have an internal evaluation framework for benchmarking prompts on many troubleshooting scenarios and if you share a case where HolmesGPT doesn't work, we will be able to add it to our test framework and fix the performance on that issue and similar ones.
Adding new data sources
If you want HolmesGPT to investigate external tickets or alert, you can add a new datasource. This requires modifying the source code and opening a PR. You can see an example PR like that here, which added support for investigating GitHub issues.
For Tasks:
Click tags to check more tools for each tasksFor Jobs:
Alternative AI tools for holmesgpt
Similar Open Source Tools
holmesgpt
HolmesGPT is an open-source DevOps assistant powered by OpenAI or any tool-calling LLM of your choice. It helps in troubleshooting Kubernetes, incident response, ticket management, automated investigation, and runbook automation in plain English. The tool connects to existing observability data, is compliance-friendly, provides transparent results, supports extensible data sources, runbook automation, and integrates with existing workflows. Users can install HolmesGPT using Brew, prebuilt Docker container, Python Poetry, or Docker. The tool requires an API key for functioning and supports OpenAI, Azure AI, and self-hosted LLMs.
llm-vscode
llm-vscode is an extension designed for all things LLM, utilizing llm-ls as its backend. It offers features such as code completion with 'ghost-text' suggestions, the ability to choose models for code generation via HTTP requests, ensuring prompt size fits within the context window, and code attribution checks. Users can configure the backend, suggestion behavior, keybindings, llm-ls settings, and tokenization options. Additionally, the extension supports testing models like Code Llama 13B, Phind/Phind-CodeLlama-34B-v2, and WizardLM/WizardCoder-Python-34B-V1.0. Development involves cloning llm-ls, building it, and setting up the llm-vscode extension for use.
tiledesk-dashboard
Tiledesk is an open-source live chat platform with integrated chatbots written in Node.js and Express. It is designed to be a multi-channel platform for web, Android, and iOS, and it can be used to increase sales or provide post-sales customer service. Tiledesk's chatbot technology allows for automation of conversations, and it also provides APIs and webhooks for connecting external applications. Additionally, it offers a marketplace for apps and features such as CRM, ticketing, and data export.
shell-ai
Shell-AI (`shai`) is a CLI utility that enables users to input commands in natural language and receive single-line command suggestions. It leverages natural language understanding and interactive CLI tools to enhance command line interactions. Users can describe tasks in plain English and receive corresponding command suggestions, making it easier to execute commands efficiently. Shell-AI supports cross-platform usage and is compatible with Azure OpenAI deployments, offering a user-friendly and efficient way to interact with the command line.
mods
AI for the command line, built for pipelines. LLM based AI is really good at interpreting the output of commands and returning the results in CLI friendly text formats like Markdown. Mods is a simple tool that makes it super easy to use AI on the command line and in your pipelines. Mods works with OpenAI, Groq, Azure OpenAI, and LocalAI To get started, install Mods and check out some of the examples below. Since Mods has built-in Markdown formatting, you may also want to grab Glow to give the output some _pizzazz_.
sage
Sage is a tool that allows users to chat with any codebase, providing a chat interface for code understanding and integration. It simplifies the process of learning how a codebase works by offering heavily documented answers sourced directly from the code. Users can set up Sage locally or on the cloud with minimal effort. The tool is designed to be easily customizable, allowing users to swap components of the pipeline and improve the algorithms powering code understanding and generation.
Deep-Live-Cam
Deep-Live-Cam is a software tool designed to assist artists in tasks such as animating custom characters or using characters as models for clothing. The tool includes built-in checks to prevent unethical applications, such as working on inappropriate media. Users are expected to use the tool responsibly and adhere to local laws, especially when using real faces for deepfake content. The tool supports both CPU and GPU acceleration for faster processing and provides a user-friendly GUI for swapping faces in images or videos.
gpt-cli
gpt-cli is a command-line interface tool for interacting with various chat language models like ChatGPT, Claude, and others. It supports model customization, usage tracking, keyboard shortcuts, multi-line input, markdown support, predefined messages, and multiple assistants. Users can easily switch between different assistants, define custom assistants, and configure model parameters and API keys in a YAML file for easy customization and management.
rclip
rclip is a command-line photo search tool powered by the OpenAI's CLIP neural network. It allows users to search for images using text queries, similar image search, and combining multiple queries. The tool extracts features from photos to enable searching and indexing, with options for previewing results in supported terminals or custom viewers. Users can install rclip on Linux, macOS, and Windows using different installation methods. The repository follows the Conventional Commits standard and welcomes contributions from the community.
log10
Log10 is a one-line Python integration to manage your LLM data. It helps you log both closed and open-source LLM calls, compare and identify the best models and prompts, store feedback for fine-tuning, collect performance metrics such as latency and usage, and perform analytics and monitor compliance for LLM powered applications. Log10 offers various integration methods, including a python LLM library wrapper, the Log10 LLM abstraction, and callbacks, to facilitate its use in both existing production environments and new projects. Pick the one that works best for you. Log10 also provides a copilot that can help you with suggestions on how to optimize your prompt, and a feedback feature that allows you to add feedback to your completions. Additionally, Log10 provides prompt provenance, session tracking and call stack functionality to help debug prompt chains. With Log10, you can use your data and feedback from users to fine-tune custom models with RLHF, and build and deploy more reliable, accurate and efficient self-hosted models. Log10 also supports collaboration, allowing you to create flexible groups to share and collaborate over all of the above features.
ML-Bench
ML-Bench is a tool designed to evaluate large language models and agents for machine learning tasks on repository-level code. It provides functionalities for data preparation, environment setup, usage, API calling, open source model fine-tuning, and inference. Users can clone the repository, load datasets, run ML-LLM-Bench, prepare data, fine-tune models, and perform inference tasks. The tool aims to facilitate the evaluation of language models and agents in the context of machine learning tasks on code repositories.
comfy-cli
Comfy-cli is a command line tool designed to facilitate the installation and management of ComfyUI, an open-source machine learning framework. Users can easily set up ComfyUI, install packages, and manage custom nodes directly from the terminal. The tool offers features such as easy installation, seamless package management, custom node management, checkpoint downloads, cross-platform compatibility, and comprehensive documentation. Comfy-cli simplifies the process of working with ComfyUI, making it convenient for users to handle various tasks related to the framework.
bilingual_book_maker
The bilingual_book_maker is an AI translation tool that uses ChatGPT to assist users in creating multi-language versions of epub/txt/srt files and books. It supports various models like gpt-4, gpt-3.5-turbo, claude-2, palm, llama-2, azure-openai, command-nightly, and gemini. Users need ChatGPT or OpenAI token, epub/txt books, internet access, and Python 3.8+. The tool provides options to specify OpenAI API key, model selection, target language, proxy server, context addition, translation style, and more. It generates bilingual books in epub format after translation. Users can test translations, set batch size, tweak prompts, and use different models like DeepL, Google Gemini, Tencent TranSmart, and more. The tool also supports retranslation, translating specific tags, and e-reader type specification. Docker usage is available for easy setup.
chatgpt-cli
ChatGPT CLI provides a powerful command-line interface for seamless interaction with ChatGPT models via OpenAI and Azure. It features streaming capabilities, extensive configuration options, and supports various modes like streaming, query, and interactive mode. Users can manage thread-based context, sliding window history, and provide custom context from any source. The CLI also offers model and thread listing, advanced configuration options, and supports GPT-4, GPT-3.5-turbo, and Perplexity's models. Installation is available via Homebrew or direct download, and users can configure settings through default values, a config.yaml file, or environment variables.
For similar tasks
holmesgpt
HolmesGPT is an open-source DevOps assistant powered by OpenAI or any tool-calling LLM of your choice. It helps in troubleshooting Kubernetes, incident response, ticket management, automated investigation, and runbook automation in plain English. The tool connects to existing observability data, is compliance-friendly, provides transparent results, supports extensible data sources, runbook automation, and integrates with existing workflows. Users can install HolmesGPT using Brew, prebuilt Docker container, Python Poetry, or Docker. The tool requires an API key for functioning and supports OpenAI, Azure AI, and self-hosted LLMs.
comfyui_LLM_party
COMFYUI LLM PARTY is a node library designed for LLM workflow development in ComfyUI, an extremely minimalist UI interface primarily used for AI drawing and SD model-based workflows. The project aims to provide a complete set of nodes for constructing LLM workflows, enabling users to easily integrate them into existing SD workflows. It features various functionalities such as API integration, local large model integration, RAG support, code interpreters, online queries, conditional statements, looping links for large models, persona mask attachment, and tool invocations for weather lookup, time lookup, knowledge base, code execution, web search, and single-page search. Users can rapidly develop web applications using API + Streamlit and utilize LLM as a tool node. Additionally, the project includes an omnipotent interpreter node that allows the large model to perform any task, with recommendations to use the 'show_text' node for display output.
For similar jobs
AirGo
AirGo is a front and rear end separation, multi user, multi protocol proxy service management system, simple and easy to use. It supports vless, vmess, shadowsocks, and hysteria2.
mosec
Mosec is a high-performance and flexible model serving framework for building ML model-enabled backend and microservices. It bridges the gap between any machine learning models you just trained and the efficient online service API. * **Highly performant** : web layer and task coordination built with Rust 🦀, which offers blazing speed in addition to efficient CPU utilization powered by async I/O * **Ease of use** : user interface purely in Python 🐍, by which users can serve their models in an ML framework-agnostic manner using the same code as they do for offline testing * **Dynamic batching** : aggregate requests from different users for batched inference and distribute results back * **Pipelined stages** : spawn multiple processes for pipelined stages to handle CPU/GPU/IO mixed workloads * **Cloud friendly** : designed to run in the cloud, with the model warmup, graceful shutdown, and Prometheus monitoring metrics, easily managed by Kubernetes or any container orchestration systems * **Do one thing well** : focus on the online serving part, users can pay attention to the model optimization and business logic
llm-code-interpreter
The 'llm-code-interpreter' repository is a deprecated plugin that provides a code interpreter on steroids for ChatGPT by E2B. It gives ChatGPT access to a sandboxed cloud environment with capabilities like running any code, accessing Linux OS, installing programs, using filesystem, running processes, and accessing the internet. The plugin exposes commands to run shell commands, read files, and write files, enabling various possibilities such as running different languages, installing programs, starting servers, deploying websites, and more. It is powered by the E2B API and is designed for agents to freely experiment within a sandboxed environment.
pezzo
Pezzo is a fully cloud-native and open-source LLMOps platform that allows users to observe and monitor AI operations, troubleshoot issues, save costs and latency, collaborate, manage prompts, and deliver AI changes instantly. It supports various clients for prompt management, observability, and caching. Users can run the full Pezzo stack locally using Docker Compose, with prerequisites including Node.js 18+, Docker, and a GraphQL Language Feature Support VSCode Extension. Contributions are welcome, and the source code is available under the Apache 2.0 License.
learn-generative-ai
Learn Cloud Applied Generative AI Engineering (GenEng) is a course focusing on the application of generative AI technologies in various industries. The course covers topics such as the economic impact of generative AI, the role of developers in adopting and integrating generative AI technologies, and the future trends in generative AI. Students will learn about tools like OpenAI API, LangChain, and Pinecone, and how to build and deploy Large Language Models (LLMs) for different applications. The course also explores the convergence of generative AI with Web 3.0 and its potential implications for decentralized intelligence.
gcloud-aio
This repository contains shared codebase for two projects: gcloud-aio and gcloud-rest. gcloud-aio is built for Python 3's asyncio, while gcloud-rest is a threadsafe requests-based implementation. It provides clients for Google Cloud services like Auth, BigQuery, Datastore, KMS, PubSub, Storage, and Task Queue. Users can install the library using pip and refer to the documentation for usage details. Developers can contribute to the project by following the contribution guide.
fluid
Fluid is an open source Kubernetes-native Distributed Dataset Orchestrator and Accelerator for data-intensive applications, such as big data and AI applications. It implements dataset abstraction, scalable cache runtime, automated data operations, elasticity and scheduling, and is runtime platform agnostic. Key concepts include Dataset and Runtime. Prerequisites include Kubernetes version > 1.16, Golang 1.18+, and Helm 3. The tool offers features like accelerating remote file accessing, machine learning, accelerating PVC, preloading dataset, and on-the-fly dataset cache scaling. Contributions are welcomed, and the project is under the Apache 2.0 license with a vendor-neutral approach.
aiges
AIGES is a core component of the Athena Serving Framework, designed as a universal encapsulation tool for AI developers to deploy AI algorithm models and engines quickly. By integrating AIGES, you can deploy AI algorithm models and engines rapidly and host them on the Athena Serving Framework, utilizing supporting auxiliary systems for networking, distribution strategies, data processing, etc. The Athena Serving Framework aims to accelerate the cloud service of AI algorithm models and engines, providing multiple guarantees for cloud service stability through cloud-native architecture. You can efficiently and securely deploy, upgrade, scale, operate, and monitor models and engines without focusing on underlying infrastructure and service-related development, governance, and operations.