gonzo

Gonzo! The Go based TUI log analysis tool

Stars: 1180

Visit

Gonzo is a powerful, real-time log analysis terminal UI tool inspired by k9s. It allows users to analyze log streams with beautiful charts, AI-powered insights, and advanced filtering directly from the terminal. The tool provides features like live streaming log processing, OTLP support, interactive dashboard with real-time charts, advanced filtering options including regex support, and AI-powered insights such as pattern detection, anomaly analysis, and root cause suggestions. Users can also configure AI models from providers like OpenAI, LM Studio, and Ollama for intelligent log analysis. Gonzo is built with Bubble Tea, Lipgloss, Cobra, Viper, and OpenTelemetry, following a clean architecture with separate modules for TUI, log analysis, frequency tracking, OTLP handling, and AI integration.

README:

Gonzo - The Go based TUI for log analysis

A powerful, real-time log analysis terminal UI inspired by k9s. Analyze log streams with beautiful charts, AI-powered insights, and advanced filtering - all from your terminal.

See it in action

Main Dashboard

Stats and Info

Everyone loves a heatmap

✨ Features

🎯 Real-Time Analysis

Live streaming - Process logs as they arrive from stdin, files, or network
OTLP native - First-class support for OpenTelemetry log format
OTLP receiver - Built-in gRPC server to receive logs via OpenTelemetry protocol
Format detection - Automatically detects JSON, logfmt, and plain text
Severity tracking - Color-coded severity levels with distribution charts

📈 Interactive Dashboard

k9s-inspired layout - Familiar 2x2 grid interface
Real-time charts - Word frequency, attributes, severity distribution, and time series
Keyboard + mouse navigation - Vim-style shortcuts plus click-to-navigate and scroll wheel support
Smart log viewer - Auto-scroll with intelligent pause/resume behavior
Fullscreen log viewer - Press f to open a dedicated fullscreen modal for log browsing with all navigation features
Global pause control - Spacebar pauses entire dashboard while buffering logs
Modal details - Deep dive into individual log entries with expandable views
Log Counts analysis - Detailed modal with heatmap visualization, pattern analysis by severity, and service distribution
AI analysis - Get intelligent insights about log patterns and anomalies with configurable models

🔍 Advanced Filtering

Regex support - Filter logs with regular expressions
Attribute search - Find logs by specific attribute values
Severity filtering - Focus on errors, warnings, or specific log levels
Interactive selection - Click or keyboard navigate to explore logs

🤖 AI-Powered Insights

Pattern detection - Automatically identify recurring issues
Anomaly analysis - Spot unusual patterns in your logs
Root cause suggestions - Get AI-powered debugging assistance
Configurable models - Choose from GPT-4, GPT-3.5, or any custom model
Multiple providers - Works with OpenAI, LM Studio, Ollama, or any OpenAI-compatible API
Local AI support - Run completely offline with local models

🚀 Quick Start

Installation

Using Go

go install github.com/control-theory/gonzo/cmd/gonzo@latest

Using Homebrew (macOS/Linux)

brew install gonzo

Download Binary

Download the latest release for your platform from the releases page.

Using Nix package manager (beta support)

nix run github:control-theory/gonzo

Build from Source

git clone https://github.com/control-theory/gonzo.git
cd gonzo
make build

📖 Usage

Basic Usage

# Read logs directly from files
gonzo -f application.log

# Read from multiple files
gonzo -f application.log -f error.log -f debug.log

# Use glob patterns to read multiple files
gonzo -f "/var/log/*.log"
gonzo -f "/var/log/app/*.log" -f "/var/log/nginx/*.log"

# Follow log files in real-time (like tail -f)
gonzo -f /var/log/app.log --follow
gonzo -f "/var/log/*.log" --follow

# Analyze logs from stdin (traditional way)
cat application.log | gonzo

# Stream logs from kubectl
kubectl logs -f deployment/my-app | gonzo

# Follow system logs
tail -f /var/log/syslog | gonzo

# Analyze Docker container logs
docker logs -f my-container 2>&1 | gonzo

# With AI analysis (requires API key)
export OPENAI_API_KEY=sk-your-key-here
gonzo -f application.log --ai-model="gpt-4"

OTLP Network Receiver

Gonzo can receive logs directly via OpenTelemetry Protocol (OTLP) over both gRPC and HTTP:

# Start Gonzo as an OTLP receiver (both gRPC on port 4317 and HTTP on port 4318)
gonzo --otlp-enabled

# Use custom ports
gonzo --otlp-enabled --otlp-grpc-port=5317 --otlp-http-port=5318

# gRPC endpoint: localhost:4317
# HTTP endpoint: http://localhost:4318/v1/logs

Example: OpenTelemetry Collector Configuration

Using gRPC:

exporters:
  otlp/gonzo_grpc:
    endpoint: localhost:4317
    tls:
      insecure: true

service:
  pipelines:
    logs:
      receivers: [your_receivers]
      processors: [your_processors]
      exporters: [otlp/gonzo_grpc]

Using HTTP:

exporters:
  otlphttp/gonzo_http:
    endpoint: http://localhost:4318/v1/logs

service:
  pipelines:
    logs:
      receivers: [your_receivers]
      processors: [your_processors]
      exporters: [otlphttp/gonzo_http]

Example: Python Application

Using gRPC:

from opentelemetry.exporter.otlp.proto.grpc._log_exporter import OTLPLogExporter

exporter = OTLPLogExporter(
    endpoint="localhost:4317",
    insecure=True
)

Using HTTP:

from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter

exporter = OTLPLogExporter(
    endpoint="http://localhost:4318/v1/logs",
)

See examples/send_otlp_logs.py for a complete example.

With AI Analysis

# Auto-select best available model (recommended) - file input
export OPENAI_API_KEY=sk-your-key-here
gonzo -f logs.json

# Or specify a particular model - file input
export OPENAI_API_KEY=sk-your-key-here
gonzo -f logs.json --ai-model="gpt-4"

# Follow logs with AI analysis
export OPENAI_API_KEY=sk-your-key-here
gonzo -f "/var/log/app.log" --follow --ai-model="gpt-4"

# Using local LM Studio (auto-selects first available)
export OPENAI_API_KEY="local-key"
export OPENAI_API_BASE="http://localhost:1234/v1"
gonzo -f logs.json

# Using Ollama (auto-selects best model like gpt-oss:20b)
export OPENAI_API_KEY="ollama"
export OPENAI_API_BASE="http://localhost:11434"
gonzo -f logs.json --follow

# Traditional stdin approach still works
export OPENAI_API_KEY=sk-your-key-here
cat logs.json | gonzo --ai-model="gpt-4"

Keyboard Shortcuts

Navigation

Key/Mouse	Action
`Tab` / `Shift+Tab`	Navigate between panels
`Mouse Click`	Click on any section to switch to it
`↑`/`↓` or `k`/`j`	Move selection up/down
`Mouse Wheel`	Scroll up/down to navigate selections
`←`/`→` or `h`/`l`	Horizontal navigation
`Enter`	View log details or open analysis modal (Counts section)
`ESC`	Close modal/cancel

Actions

Key	Action
`Space`	Pause/unpause entire dashboard
`/`	Enter filter mode (regex supported)
`s`	Search and highlight text in logs
`f`	Open fullscreen log viewer modal
`c`	Toggle Host/Service columns in log view
`r`	Reset all data (manual reset)
`u` / `U`	Cycle update intervals (forward/backward)
`i`	AI analysis (in detail view)
`m`	Switch AI model (shows available models)
`?` / `h`	Show help
`q` / `Ctrl+C`	Quit

Log Viewer Navigation

Key	Action
`Home`	Jump to top of log buffer (stops auto-scroll)
`End`	Jump to latest logs (resumes auto-scroll)
`PgUp` / `PgDn`	Navigate by pages (10 entries at a time)
`↑`/`↓` or `k`/`j`	Navigate entries with smart auto-scroll

AI Chat (in log detail modal)

Key	Action
`c`	Start chat with AI about current log
`Tab`	Switch between log details and chat pane
`m`	Switch AI model (works in modal too)

Log Counts Analysis Modal

Press Enter on the Counts section to open a comprehensive analysis modal featuring:

🔥 Real-Time Heatmap Visualization

Time-series heatmap showing severity levels vs. time (1-minute resolution)
60-minute rolling window with automatic scaling per severity level
Color-coded intensity using ASCII characters (░▒▓█) with gradient effects
Precise alignment with time headers showing minutes ago (60, 50, 40, ..., 10, 0)
Receive time architecture - visualization based on when logs were received for reliable display

🔍 Pattern Analysis by Severity

Top 3 patterns per severity using drain3 pattern extraction algorithm
Severity-specific tracking with dedicated drain3 instances for each level
Real-time pattern detection as logs arrive and are processed
Accurate pattern counts maintained separately for each severity level

🏢 Service Distribution Analysis

Top 3 services per severity showing which services generate each log level
Service name extraction from common attributes (service.name, service, app, etc.)
Real-time updates as new logs are processed and analyzed
Fallback to host information when service names are not available

⌨️ Modal Navigation

Scrollable content using mouse wheel or arrow keys
ESC to close and return to main dashboard
Full-width display maximizing screen real estate for data visualization
Real-time updates - data refreshes automatically as new logs arrive

The modal uses the same receive time architecture as the main dashboard, ensuring consistent and reliable visualization regardless of log timestamp accuracy or clock skew issues.

⚙️ Configuration

Command Line Options

gonzo [flags]
gonzo [command]

Commands:
  version     Print version information
  help        Help about any command
  completion  Generate shell autocompletion

Flags:
  -f, --file stringArray           Files or file globs to read logs from (can specify multiple)
  --follow                     Follow log files like 'tail -f' (watch for new lines in real-time)
  -u, --update-interval duration   Dashboard update interval (default: 1s)
  -b, --log-buffer int             Maximum log entries to keep (default: 1000)
  -m, --memory-size int            Maximum frequency entries (default: 10000)
  --ai-model string            AI model for analysis (auto-selects best available if not specified)
  -t, --test-mode                  Run without TTY for testing
  -v, --version                    Print version information
  --config string              Config file (default: $HOME/.config/gonzo/config.yml)
  -h, --help                       Show help message

Configuration File

Create ~/.config/gonzo/config.yml for persistent settings:

# File input configuration
files:
  - "/var/log/app.log"
  - "/var/log/error.log"
  - "/var/log/*.log"  # Glob patterns supported
follow: true  # Enable follow mode (like tail -f)

# Update frequency for dashboard refresh
update-interval: 2s

# Buffer sizes
log-buffer: 2000
memory-size: 15000

# Development/testing
test-mode: false

# AI configuration
ai-model: "gpt-4"

See examples/config.yaml for a complete configuration example with detailed comments.

AI Configuration

Gonzo supports multiple AI providers for intelligent log analysis. Configure using command line flags and environment variables. You can switch between available models at runtime using the m key.

OpenAI

# Set your API key
export OPENAI_API_KEY="sk-your-actual-key-here"

# Auto-select best available model (recommended)
cat logs.json | gonzo

# Or specify a particular model
cat logs.json | gonzo --ai-model="gpt-4"

LM Studio (Local AI)

# 1. Start LM Studio server with a model loaded
# 2. Set environment variables (IMPORTANT: include /v1 in URL)
export OPENAI_API_KEY="local-key"
export OPENAI_API_BASE="http://localhost:1234/v1"

# Auto-select first available model (recommended)
cat logs.json | gonzo

# Or specify the exact model name from LM Studio
cat logs.json | gonzo --ai-model="openai/gpt-oss-120b"

Ollama (Local AI)

# 1. Start Ollama: ollama serve
# 2. Pull a model: ollama pull gpt-oss:20b
# 3. Set environment variables (note: no /v1 suffix needed)
export OPENAI_API_KEY="ollama"
export OPENAI_API_BASE="http://localhost:11434"

# Auto-select best model (prefers gpt-oss, llama3, mistral, etc.)
cat logs.json | gonzo

# Or specify a particular model
cat logs.json | gonzo --ai-model="gpt-oss:20b"
cat logs.json | gonzo --ai-model="llama3"

Custom OpenAI-Compatible APIs

# For any OpenAI-compatible API endpoint
export OPENAI_API_KEY="your-api-key"
export OPENAI_API_BASE="https://api.your-provider.com/v1"
cat logs.json | gonzo --ai-model="your-model-name"

Runtime Model Switching

Once Gonzo is running, you can switch between available AI models without restarting:

Press m anywhere in the interface to open the model selection modal
Navigate with arrow keys, page up/down, or mouse wheel
Select a model with Enter
Cancel with Escape

The model selection modal shows:

All available models from your configured AI provider
Current active model (highlighted in green)
Dynamic sizing based on terminal height
Scroll indicators when there are many models

Note: Model switching requires the AI service to be properly configured and running. The modal will only appear if models are available from your AI provider.

Auto Model Selection

When you don't specify the --ai-model flag, Gonzo automatically selects the best available model:

Selection Priority:

OpenAI: Prefers gpt-4 → gpt-3.5-turbo → first available
Ollama: Prefers gpt-oss:20b → llama3 → mistral → codellama → first available
LM Studio: Uses first available model from the server
Other providers: Uses first available model

Benefits:

✅ No need to know model names beforehand
✅ Works immediately with any AI provider
✅ Intelligent defaults for better performance
✅ Still allows manual model selection with m key

Example: Instead of gonzo --ai-model="llama3", simply run gonzo and it will auto-select llama3 if available.

Troubleshooting AI Setup

LM Studio Issues:

✅ Ensure server is running and model is loaded
✅ Use full model name: --ai-model="openai/model-name"
✅ Include /v1 in base URL: http://localhost:1234/v1
✅ Check available models: curl http://localhost:1234/v1/models

Ollama Issues:

✅ Start server: ollama serve
✅ Verify model: ollama list
✅ Test API: curl http://localhost:11434/api/tags
✅ Use correct URL: http://localhost:11434 (no /v1 suffix)
✅ Model names include tags: gpt-oss:20b, llama3:8b

OpenAI Issues:

✅ Verify API key is valid and has credits
✅ Check model availability (gpt-4 requires API access)

Environment Variables

Variable	Description
`OPENAI_API_KEY`	API key for AI analysis (required for AI features)
`OPENAI_API_BASE`	Custom API endpoint (default: https://api.openai.com/v1)
`GONZO_FILES`	Comma-separated list of files/globs to read (equivalent to -f flags)
`GONZO_FOLLOW`	Enable follow mode (true/false)
`GONZO_UPDATE_INTERVAL`	Override update interval
`GONZO_LOG_BUFFER`	Override log buffer size
`GONZO_MEMORY_SIZE`	Override memory size
`GONZO_AI_MODEL`	Override default AI model
`GONZO_TEST_MODE`	Enable test mode
`NO_COLOR`	Disable colored output

Shell Completion

Enable shell completion for better CLI experience:

# Bash
source <(gonzo completion bash)

# Zsh  
source <(gonzo completion zsh)

# Fish
gonzo completion fish | source

# PowerShell
gonzo completion powershell | Out-String | Invoke-Expression

For permanent setup, save the completion script to your shell's completion directory.

K9s Integration

By leveraging K9s plugin system Gonzo integrates seamlessly with K9s for real-time Kubernetes log analysis.

Setup

Add this plugin to your $XDG_CONFIG_HOME/k9s/plugins.yaml file:

plugins:
  gonzo:
    shortCut: Ctrl-L
    description: "Gonzo log analysis"
    scopes:
    - po
    command: sh
    background: false
    args:
    - -c
    - "kubectl logs -f $NAME -n $NAMESPACE --context $CONTEXT | gonzo"

⚠️ NOTE: on macOS although it is not required, defining XDG_CONFIG_HOME=~/.config is recommended in order to maintain consistency with Linux configuration practices.

Usage

Launch k9s and navigate to pods
Select a pod and press ctrl-l
Gonzo opens with live log streaming and analysis

🏗️ Architecture

Gonzo is built with:

Bubble Tea - Terminal UI framework
Lipgloss - Styling and layout
Bubbles - TUI components
Cobra - CLI framework
Viper - Configuration management
OpenTelemetry - Native OTLP support
Large amounts of ☕️

The architecture follows a clean separation:

cmd/gonzo/              # Main application entry
internal/
├── tui/                # Terminal UI implementation
├── analyzer/           # Log analysis engine
├── memory/            # Frequency tracking
├── otlplog/           # OTLP format handling
└── ai/                # AI integration

🧪 Development

Prerequisites

Go 1.21 or higher
Make (optional, for convenience)

Building

# Quick build
make build

# Run tests
make test

# Build for all platforms
make cross-build

# Development mode (format, vet, test, build)
make dev

Testing

# Run unit tests
make test

# Run with race detection
make test-race

# Integration tests
make test-integration

# Test with sample data
make demo

🤝 Contributing

We love contributions! Please see CONTRIBUTING.md for details.

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

📝 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

Inspired by k9s for the amazing TUI patterns
Built with Charm libraries for beautiful terminal UIs
OpenTelemetry community for the OTLP specifications

📚 Documentation

Usage Guide - Detailed usage instructions
Victoria Logs Integration - Using Gonzo with Victoria Logs API
Contributing Guide - How to contribute
Changelog - Version history

🐛 Reporting Issues

Found a bug? Please open an issue with:

Your OS and Go version
Steps to reproduce
Expected vs actual behavior
Log samples (sanitized if needed)

⭐ Star History

If you find this project useful, please consider giving it a star! It helps others discover the tool.

Made with ❤️ by ControlTheory and the Gonzo community

For Tasks:

Click tags to check more tools for each tasks

analyze logs filter logs detect patterns analyze anomalies get ai insights

For Jobs:

log analyst devops engineer system administrator data engineer ai engineer

Alternative AI tools for gonzo

Similar Open Source Tools

gonzo

github

: 1.2k

cortex.cpp

Cortex.cpp is an open-source platform designed as the brain for robots, offering functionalities such as vision, speech, language, tabular data processing, and action. It provides an AI platform for running AI models with multi-engine support, hardware optimization with automatic GPU detection, and an OpenAI-compatible API. Users can download models from the Hugging Face model hub, run models, manage resources, and access advanced features like multiple quantizations and engine management. The tool is under active development, promising rapid improvements for users.

github

: 2.6k

zcf

ZCF (Zero-Config Claude-Code Flow) is a tool that provides zero-configuration, one-click setup for Claude Code with bilingual support, intelligent agent system, and personalized AI assistant. It offers an interactive menu for easy operations and direct commands for quick execution. The tool supports bilingual operation with automatic language switching and customizable AI output styles. ZCF also includes features like BMad Workflow for enterprise-grade workflow system, Spec Workflow for structured feature development, CCR (Claude Code Router) support for proxy routing, and CCometixLine for real-time usage tracking. It provides smart installation, complete configuration management, and core features like professional agents, command system, and smart configuration. ZCF is cross-platform compatible, supports Windows and Termux environments, and includes security features like dangerous operation confirmation mechanism.

github

: 1.2k

VimLM

VimLM is an AI-powered coding assistant for Vim that integrates AI for code generation, refactoring, and documentation directly into your Vim workflow. It offers native Vim integration with split-window responses and intuitive keybindings, offline first execution with MLX-compatible models, contextual awareness with seamless integration with codebase and external resources, conversational workflow for iterating on responses, project scaffolding for generating and deploying code blocks, and extensibility for creating custom LLM workflows with command chains.

github

: 193

paperless-gpt

paperless-gpt is a tool designed to generate accurate and meaningful document titles and tags for paperless-ngx using Large Language Models (LLMs). It supports multiple LLM providers, including OpenAI and Ollama. With paperless-gpt, you can streamline your document management by automatically suggesting appropriate titles and tags based on the content of your scanned documents. The tool offers features like multiple LLM support, customizable prompts, easy integration with paperless-ngx, user-friendly interface for reviewing and applying suggestions, dockerized deployment, automatic document processing, and an experimental OCR feature.

github

: 724

sim

Sim is a platform that allows users to build and deploy AI agent workflows quickly and easily. It provides cloud-hosted and self-hosted options, along with support for local AI models. Users can set up the application using Docker Compose, Dev Containers, or manual setup with PostgreSQL and pgvector extension. The platform utilizes technologies like Next.js, Bun, PostgreSQL with Drizzle ORM, Better Auth for authentication, Shadcn and Tailwind CSS for UI, Zustand for state management, ReactFlow for flow editor, Fumadocs for documentation, Turborepo for monorepo management, Socket.io for real-time communication, and Trigger.dev for background jobs.

github

: 13.8k

klavis

Klavis AI is a production-ready solution for managing Multiple Communication Protocol (MCP) servers. It offers self-hosted solutions and a hosted service with enterprise OAuth support. With Klavis AI, users can easily deploy and manage over 50 MCP servers for various services like GitHub, Gmail, Google Sheets, YouTube, Slack, and more. The tool provides instant access to MCP servers, seamless authentication, and integration with AI frameworks, making it ideal for individuals and businesses looking to streamline their communication and data management workflows.

github

: 4.0k

aicommit2

AICommit2 is a Reactive CLI tool that streamlines interactions with various AI providers such as OpenAI, Anthropic Claude, Gemini, Mistral AI, Cohere, and unofficial providers like Huggingface and Clova X. Users can request multiple AI simultaneously to generate git commit messages without waiting for all AI responses. The tool runs 'git diff' to grab code changes, sends them to configured AI, and returns the AI-generated commit message. Users can set API keys or Cookies for different providers and configure options like locale, generate number of messages, commit type, proxy, timeout, max-length, and more. AICommit2 can be used both locally with Ollama and remotely with supported providers, offering flexibility and efficiency in generating commit messages.

github

: 242

readme-ai

README-AI is a developer tool that auto-generates README.md files using a combination of data extraction and generative AI. It streamlines documentation creation and maintenance, enhancing developer productivity. This project aims to enable all skill levels, across all domains, to better understand, use, and contribute to open-source software. It offers flexible README generation, supports multiple large language models (LLMs), provides customizable output options, works with various programming languages and project types, and includes an offline mode for generating boilerplate README files without external API calls.

github

: 1.5k

one

ONE is a modern web and AI agent development toolkit that empowers developers to build AI-powered applications with high performance, beautiful UI, AI integration, responsive design, type safety, and great developer experience. It is perfect for building modern web applications, from simple landing pages to complex AI-powered platforms.

github

: 58

monoscope

Monoscope is an open-source monitoring and observability platform that uses artificial intelligence to understand and monitor systems automatically. It allows users to ingest and explore logs, traces, and metrics in S3 buckets, query in natural language via LLMs, and create AI agents to detect anomalies. Key capabilities include universal data ingestion, AI-powered understanding, natural language interface, cost-effective storage, and zero configuration. Monoscope is designed to reduce alert fatigue, catch issues before they impact users, and provide visibility across complex systems.

github

: 187

wingman

The LLM Platform, also known as Inference Hub, is an open-source tool designed to simplify the development and deployment of large language model applications at scale. It provides a unified framework for integrating and managing multiple LLM vendors, models, and related services through a flexible approach. The platform supports various LLM providers, document processing, RAG, advanced AI workflows, infrastructure operations, and flexible configuration using YAML files. Its modular and extensible architecture allows developers to plug in different providers and services as needed. Key components include completers, embedders, renderers, synthesizers, transcribers, document processors, segmenters, retrievers, summarizers, translators, AI workflows, tools, and infrastructure components. Use cases range from enterprise AI applications to scalable LLM deployment and custom AI pipelines. Integrations with LLM providers like OpenAI, Azure OpenAI, Anthropic, Google Gemini, AWS Bedrock, Groq, Mistral AI, xAI, Hugging Face, and more are supported.

github

: 63

R2R

R2R (RAG to Riches) is a fast and efficient framework for serving high-quality Retrieval-Augmented Generation (RAG) to end users. The framework is designed with customizable pipelines and a feature-rich FastAPI implementation, enabling developers to quickly deploy and scale RAG-based applications. R2R was conceived to bridge the gap between local LLM experimentation and scalable production solutions. **R2R is to LangChain/LlamaIndex what NextJS is to React**. A JavaScript client for R2R deployments can be found here. ### Key Features * **🚀 Deploy** : Instantly launch production-ready RAG pipelines with streaming capabilities. * **🧩 Customize** : Tailor your pipeline with intuitive configuration files. * **🔌 Extend** : Enhance your pipeline with custom code integrations. * **⚖️ Autoscale** : Scale your pipeline effortlessly in the cloud using SciPhi. * **🤖 OSS** : Benefit from a framework developed by the open-source community, designed to simplify RAG deployment.

github

: 5.9k

evalchemy

Evalchemy is a unified and easy-to-use toolkit for evaluating language models, focusing on post-trained models. It integrates multiple existing benchmarks such as RepoBench, AlpacaEval, and ZeroEval. Key features include unified installation, parallel evaluation, simplified usage, and results management. Users can run various benchmarks with a consistent command-line interface and track results locally or integrate with a database for systematic tracking and leaderboard submission.

github

: 317

CrewAI-GUI

CrewAI-GUI is a Node-Based Frontend tool designed to revolutionize AI workflow creation. It empowers users to design complex AI agent interactions through an intuitive drag-and-drop interface, export designs to JSON for modularity and reusability, and supports both GPT-4 API and Ollama for flexible AI backend. The tool ensures cross-platform compatibility, allowing users to create AI workflows on Windows, Linux, or macOS efficiently.

github

: 88

photo-ai

100xPhoto is a powerful AI image platform that enables users to generate stunning images and train custom AI models. It provides an intuitive interface for creating unique AI-generated artwork and training personalized models on image datasets. The platform is built with cutting-edge technology and offers robust capabilities for AI image generation and model training.

github

: 120

For similar tasks

Awesome-LLM4Cybersecurity

The repository 'Awesome-LLM4Cybersecurity' provides a comprehensive overview of the applications of Large Language Models (LLMs) in cybersecurity. It includes a systematic literature review covering topics such as constructing cybersecurity-oriented domain LLMs, potential applications of LLMs in cybersecurity, and research directions in the field. The repository analyzes various benchmarks, datasets, and applications of LLMs in cybersecurity tasks like threat intelligence, fuzzing, vulnerabilities detection, insecure code generation, program repair, anomaly detection, and LLM-assisted attacks.

github

: 681

gonzo

github

: 1.2k

shell_gpt

ShellGPT is a command-line productivity tool powered by AI large language models (LLMs). This command-line tool offers streamlined generation of shell commands, code snippets, documentation, eliminating the need for external resources (like Google search). Supports Linux, macOS, Windows and compatible with all major Shells like PowerShell, CMD, Bash, Zsh, etc.

github

: 9.0k

holoinsight

HoloInsight is a cloud-native observability platform that provides low-cost and high-performance monitoring services for cloud-native applications. It offers deep insights through real-time log analysis and AI integration. The platform is designed to help users gain a comprehensive understanding of their applications' performance and behavior in the cloud environment. HoloInsight is easy to deploy using Docker and Kubernetes, making it a versatile tool for monitoring and optimizing cloud-native applications. With a focus on scalability and efficiency, HoloInsight is suitable for organizations looking to enhance their observability and monitoring capabilities in the cloud.

github

: 310

WatchAlert

WatchAlert is a lightweight monitoring and alerting engine tailored for cloud-native environments, focusing on observability and stability themes. It provides comprehensive monitoring and alerting support, including AI-powered alert analysis for efficient troubleshooting. WatchAlert integrates with various data sources such as Prometheus, VictoriaMetrics, Loki, Elasticsearch, AliCloud SLS, Jaeger, Kubernetes, and different network protocols for monitoring and supports alert notifications via multiple channels like Feishu, DingTalk, WeChat Work, email, and custom hooks. It is optimized for cloud-native environments, easy to use, offers flexible alert rule configurations, and specializes in stability scenarios to help users quickly identify and resolve issues, providing a reliable monitoring and alerting solution to enhance operational efficiency and reduce maintenance costs.

github

: 566

aitom

AITom is an open-source platform for AI-driven cellular electron cryo-tomography analysis. It is developed to process large amounts of Cryo-ET data, reconstruct, detect, classify, recover, and spatially model different cellular components using state-of-the-art machine learning approaches. The platform aims to automate cellular structure discovery and provide new insights into molecular biology and medical applications.

github

: 131

page-assist

Page Assist is an open-source Chrome Extension that provides a Sidebar and Web UI for your Local AI model. It allows you to interact with your model from any webpage.

github

: 6.1k

For similar jobs

sweep

Sweep is an AI junior developer that turns bugs and feature requests into code changes. It automatically handles developer experience improvements like adding type hints and improving test coverage.

github

: 7.1k

teams-ai

The Teams AI Library is a software development kit (SDK) that helps developers create bots that can interact with Teams and Microsoft 365 applications. It is built on top of the Bot Framework SDK and simplifies the process of developing bots that interact with Teams' artificial intelligence capabilities. The SDK is available for JavaScript/TypeScript, .NET, and Python.

github

: 502

ai-guide

This guide is dedicated to Large Language Models (LLMs) that you can run on your home computer. It assumes your PC is a lower-end, non-gaming setup.

github

: 159

classifai

Supercharge WordPress Content Workflows and Engagement with Artificial Intelligence. Tap into leading cloud-based services like OpenAI, Microsoft Azure AI, Google Gemini and IBM Watson to augment your WordPress-powered websites. Publish content faster while improving SEO performance and increasing audience engagement. ClassifAI integrates Artificial Intelligence and Machine Learning technologies to lighten your workload and eliminate tedious tasks, giving you more time to create original content that matters.

github

: 620

chatbot-ui

Chatbot UI is an open-source AI chat app that allows users to create and deploy their own AI chatbots. It is easy to use and can be customized to fit any need. Chatbot UI is perfect for businesses, developers, and anyone who wants to create a chatbot.

github

: 27.7k

BricksLLM

BricksLLM is a cloud native AI gateway written in Go. Currently, it provides native support for OpenAI, Anthropic, Azure OpenAI and vLLM. BricksLLM aims to provide enterprise level infrastructure that can power any LLM production use cases. Here are some use cases for BricksLLM: * Set LLM usage limits for users on different pricing tiers * Track LLM usage on a per user and per organization basis * Block or redact requests containing PIIs * Improve LLM reliability with failovers, retries and caching * Distribute API keys with rate limits and cost limits for internal development/production use cases * Distribute API keys with rate limits and cost limits for students

github

: 953

uAgents

uAgents is a Python library developed by Fetch.ai that allows for the creation of autonomous AI agents. These agents can perform various tasks on a schedule or take action on various events. uAgents are easy to create and manage, and they are connected to a fast-growing network of other uAgents. They are also secure, with cryptographically secured messages and wallets.

github

: 1.3k

griptape

Griptape is a modular Python framework for building AI-powered applications that securely connect to your enterprise data and APIs. It offers developers the ability to maintain control and flexibility at every step. Griptape's core components include Structures (Agents, Pipelines, and Workflows), Tasks, Tools, Memory (Conversation Memory, Task Memory, and Meta Memory), Drivers (Prompt and Embedding Drivers, Vector Store Drivers, Image Generation Drivers, Image Query Drivers, SQL Drivers, Web Scraper Drivers, and Conversation Memory Drivers), Engines (Query Engines, Extraction Engines, Summary Engines, Image Generation Engines, and Image Query Engines), and additional components (Rulesets, Loaders, Artifacts, Chunkers, and Tokenizers). Griptape enables developers to create AI-powered applications with ease and efficiency.

github

: 2.2k