
dot-ai
Intelligent dual-mode agent for deploying applications to ANY Kubernetes cluster through dynamic discovery and plain English governance
Stars: 108

Dot-ai is a machine learning library designed to simplify the process of building and deploying AI models. It provides a wide range of tools and utilities for data preprocessing, model training, and evaluation. With Dot-ai, users can easily create and experiment with various machine learning algorithms without the need for extensive coding knowledge. The library is built with scalability and performance in mind, making it suitable for both small-scale projects and large-scale applications. Whether you are a beginner or an experienced data scientist, Dot-ai offers a user-friendly interface to streamline your AI development workflow.
README:
DevOps AI Toolkit is an AI-powered development productivity platform that enhances software development workflows through intelligent automation and AI-driven assistance.
- Developers: Deploy applications without needing deep Kubernetes expertise
- Platform Engineers: Create organizational deployment patterns that enhance AI recommendations with institutional knowledge and best practices, and scan cluster resources to enable semantic matching for dramatically improved recommendation accuracy
- Security Engineers: Define governance policies that integrate into deployment workflows with optional Kyverno enforcement
- DevOps Engineers: Quickly diagnose and fix Kubernetes issues without deep troubleshooting expertise
- SRE Teams: Automate root cause analysis and generate executable remediation commands
- Support Teams: Handle incident response with AI-guided investigation and repair workflows
- Documentation Maintainers: Automatically validate documentation accuracy and catch outdated content
- Technical Writers: Identify which sections need updates and prioritize work effectively
- Open Source Maintainers: Ensure documentation works correctly for new contributors
- Development Teams: Share proven prompts across projects without file management
- Project Managers: Standardize workflows with consistent prompt usage across teams
- Individual Developers: Access curated prompt library via native slash commands
- AI Agents: Integrate all capabilities with Claude Code, Cursor, or VS Code for conversational workflows
- REST API: Access all tools via standard HTTP endpoints for CI/CD pipelines, automation scripts, and traditional applications
π Smart Discovery: Automatically finds all available resources and operators in your cluster
π§ Semantic Capability Management: Discovers what each resource actually does for intelligent matching
π€ AI Recommendations: Smart intent clarification gathers missing context, then provides deployment suggestions tailored to your specific cluster setup with enhanced semantic understanding
π§ Operator-Aware: Leverages custom operators and CRDs when available
π Complete Workflow: From discovery to deployment with automated Kubernetes integration
Transform how AI understands your cluster by discovering semantic capabilities of each resource:
The Problem: Traditional discovery sees sqls.devopstoolkit.live
as a meaningless name among hundreds of resources.
The Solution: Capability management teaches the system that sqls.devopstoolkit.live
handles PostgreSQL databases with multi-cloud support.
Before Capability Management:
User: "I need a PostgreSQL database"
AI: Gets 400+ generic resource names β picks complex multi-resource solution
Result: Misses optimal single-resource solutions
After Capability Management:
User: "I need a PostgreSQL database"
AI: Gets pre-filtered relevant resources with rich context
Result: Finds sqls.devopstoolkit.live as perfect match β¨
Get Started: See the Tools and Features Overview for complete guide to all available tools including capability management, deployment recommendations, and workflow integration.
π AI-Powered Root Cause Analysis: Multi-step investigation loop identifies the real cause behind Kubernetes failures
π οΈ Executable Remediation: Generates specific kubectl commands with risk assessment and validation
β‘ Dual Execution Modes: Manual approval workflow or automatic execution based on confidence thresholds
π Safety Mechanisms: Automatic fallback to manual mode when validation discovers additional issues
π― Cross-Resource Intelligence: Understands how pod issues may require fixes in different resource types (storage, networking, etc.)
π Automated Testing: Validates documentation by executing commands and testing examples
π Two-Phase Validation: Tests both functionality (does it work?) and semantic accuracy (are descriptions truthful?)
π οΈ Fix Application: User-driven selection and application of recommended documentation improvements
πΎ Session Management: Resumable testing workflows for large documentation sets
ποΈ Pattern Creation: Define organizational deployment patterns that capture institutional knowledge
π§ AI Enhancement: Patterns automatically enhance deployment recommendations with organizational context
π Semantic Search: Uses Vector DB (Qdrant) for intelligent pattern matching based on user intent
π Best Practices: Share deployment standards across teams through reusable patterns
π‘οΈ Policy Creation: Define governance policies that guide users toward compliant configurations
π€ Kyverno Generation: Automatically generates Kyverno ClusterPolicies for active enforcement
π― Proactive Governance: Prevents configuration drift by embedding compliance into the recommendation workflow
π Vector Storage: Uses Qdrant Vector DB for semantic policy matching and retrieval
π― Native Slash Commands: Prompts appear as /dot-ai:prompt-name
in your coding agent
π Curated Library: Access proven prompts for code review, documentation, architecture, and project management
π Zero Setup: Connect to MCP server and prompts are immediately available across all projects
π€ Team Consistency: Standardized prompt usage with centralized management
β‘ MCP Integration: Works seamlessly with Claude Code, Cursor, or VS Code through Model Context Protocol
π€ Conversational Interface: Natural language interaction for deployment, documentation testing, pattern management, and shared prompt workflows
Setup Required: See the MCP Setup Guide for complete configuration instructions.
This video explains the platform engineering problem and demonstrates the Kubernetes deployment recommendation workflow from intent to running applications.
For Kubernetes deployment and documentation testing:
-
Claude API key (required for AI analysis)
- Get your API key from Anthropic Console (requires account login)
- Set it as environment variable:
export ANTHROPIC_API_KEY=your_api_key_here
For shared prompts library:
- No API key required - Works with any MCP-enabled coding agent (other features like deployments do require ANTHROPIC_API_KEY)
For Kubernetes deployment recommendations:
-
kubectl configured with cluster access
- Verify cluster access with:
kubectl get nodes
- Should show your cluster nodes without authentication errors
- Verify cluster access with:
For documentation testing:
- Documentation files to test (Markdown, HTML, etc.)
- File system access to the documentation you want to validate
For organizational pattern management:
- Vector DB service (Qdrant) for pattern storage and semantic search
- OpenAI API key (required) for semantic pattern matching and vector operations
For policy management and governance:
- Vector DB service (Qdrant) for policy storage and semantic search
- OpenAI API key (required) for semantic policy matching and vector operations
- Optional: Kyverno installed in cluster for active policy enforcement
DevOps AI Toolkit is designed to be used through AI development tools via MCP (Model Context Protocol). No direct installation needed - simply configure your AI tool to connect to the MCP server.
π― Recommended: Docker Setup (Complete Stack) Perfect for getting all features working immediately with minimal setup:
- Download Docker Compose configuration:
curl -o docker-compose-dot-ai.yaml https://raw.githubusercontent.com/vfarcic/dot-ai/main/docker-compose-dot-ai.yaml
- Set environment variables and create MCP configuration:
# Set your API keys
export ANTHROPIC_API_KEY="sk-ant-api03-your-key-here"
export OPENAI_API_KEY="sk-proj-your-openai-key-here"
# Create MCP configuration for Claude Code
cat > .mcp.json << 'EOF'
{
"mcpServers": {
"dot-ai": {
"command": "docker",
"args": [
"compose",
"-f",
"docker-compose-dot-ai.yaml",
"--env-file",
".env",
"run",
"--rm",
"--remove-orphans",
"dot-ai"
]
}
}
}
EOF
What you get:
- β Complete Stack: MCP server + Qdrant vector database included
- β All Features Working: Capability management, pattern storage, policy governance, semantic search
- β No External Dependencies: Everything runs in containers
- β Kubernetes Integration: Direct kubectl access to your clusters
Alternative Methods: See the MCP Setup Guide for NPX (Node.js) and Development setup options.
- Start your MCP client:
claude # or your preferred MCP-enabled AI tool
# Verify everything works by asking:
"Show dot-ai status"
- Use conversational workflows:
Example: Kubernetes Deployment
User: I want to deploy a web application to my cluster
Agent: I'll help you deploy a web application. Let me get recommendations. First, a few questions to provide better suggestions:
What type of web application is this? Is it for development or production?
Does it need external access?
[Uses recommend tool for clarification]
User: It's a production Node.js API that needs external access
Agent: Perfect! Based on your production requirements, I found 3 deployment options.
Let's use the Production Web Stack with external access.
What's your application name and container image?
[Uses recommend tool with refined intent]
User: App name is "myapp" and image is "myapp:v1.0.0"
Agent: Excellent! Generating production-ready manifests and deploying...
[Uses chooseSolution, answerQuestion, generateManifests, deployManifests]
Agent: β
Successfully deployed! Your production API is running with external access.
Example: Capability Management
User: I want to scan my cluster for resource capabilities to improve recommendations
[Uses manageOrgData with capabilities scanning]
Agent: Would you like to scan all cluster resources or specify a subset?
Options: 1) All resources 2) Specific subset
User: All resources in auto mode
Agent: Starting comprehensive cluster capability scan...
β
Capability scan completed! Processed cluster resources successfully.
User: Now I need a PostgreSQL database
Agent: Let me get enhanced recommendations using your capability data.
[Uses recommend tool with capability pre-filtering]
Agent: Perfect! I found sqls.devopstoolkit.live as the top match - it's a managed database solution supporting PostgreSQL with multi-cloud capabilities and low complexity. Much better than the generic StatefulSet approach I would have suggested before!
Example: Kubernetes Issue Remediation
User: Something is wrong with my database in postgres-demo namespace
Agent: I'll investigate the database issue using AI-powered analysis.
[Uses remediate tool for systematic investigation]
Agent: π Root Cause (95% confidence): PostgreSQL pod can't start because the required PersistentVolumeClaim 'postgres-pvc' is missing.
π§ Recommended Fix: Create missing PVC
- Risk Level: Low
- Command: kubectl apply [PVC manifest]
Choose execution: 1) Execute via MCP 2) Show commands
User: 1
Agent: β
Issue Resolved! Created postgres-pvc, pod transitioned to Running state. Database is operational!
Example: Policy Management
User: I want to create a policy requiring resource limits on all deployments
Agent: I'll help you create a governance policy for resource limits. Let me start the creation workflow.
[Uses manageOrgData with policy creation]
Agent: Please describe your resource limits policy intent:
User: All container deployments must have CPU and memory limits to prevent resource exhaustion. CPU limits should be between 100m-2000m, memory between 128Mi-4Gi.
Agent: Excellent! I've created your Resource Limits Policy and generated a Kyverno ClusterPolicy for enforcement.
Would you like to:
1. Store policy intent only (for AI guidance)
2. Apply Kyverno policy to cluster (active enforcement)
User: Apply the Kyverno policy for active enforcement
Agent: β
Policy deployed! Now when users deploy applications, they'll get required questions for CPU/memory limits with your specified ranges, and any non-compliant deployments will be blocked by Kyverno.
Example: Documentation Testing
User: I want to test my README.md file to make sure all the examples work
Agent: I'll help you test your README.md for accuracy. Let me start a documentation testing session.
[Uses testDocs tool]
Agent: Found 6 testable sections in your README. Testing installation instructions...
β
npm install command works correctly
β Configuration example has wrong port number (8080 vs 3000)
β οΈ Claims "works out of the box" but requires additional setup
Which issues would you like me to help you fix?
User: Fix the port number directly in the doc, and I'll create a GitHub issue for the setup requirements.
Agent: β
Documentation testing complete! Fixed 1 issue directly, 1 issue tracked externally.
Note: Conversational examples are illustrative - actual AI responses will vary based on specific context and implementation.
Example: Shared Prompts Library
# Conversational approach
User: I want to create a new PRD for a feature
Agent: I'll help you create a documentation-first PRD. Let me start the process.
[Uses prd-create prompt via /dot-ai:prd-create]
Agent: Great! I've created GitHub issue #34 and the PRD file. What feature would you like to document?
# Direct slash command approach
User: /dot-ai:prd-create
Agent: I'm executing the PRD creation workflow. Please describe the feature you want to create a PRD for...
π Complete MCP Setup Guide β - Detailed configuration, troubleshooting, and examples
MCP server won't start:
- Verify environment variables are correctly configured in
.mcp.json
env section - Check session directory exists and is writable
- Ensure
ANTHROPIC_API_KEY
is valid
"No active cluster" errors:
- Verify kubectl connectivity:
kubectl cluster-info
- Check KUBECONFIG path in environment variables
- Test cluster access:
kubectl get nodes
- MCP Setup Guide - Complete configuration instructions for AI tools integration
- Tools and Features Overview - Comprehensive guide to all available tools and features
- Issues: GitHub Issues
We welcome contributions! Please:
- Fork the repository and create a feature branch
- Run tests with
npm test
to ensure changes work correctly - Follow existing code style and conventions
- Submit a pull request with a clear description of changes
MIT License - see LICENSE file for details.
DevOps AI Toolkit - AI-powered development productivity platform for enhanced software development workflows.
For Tasks:
Click tags to check more tools for each tasksFor Jobs:
Alternative AI tools for dot-ai
Similar Open Source Tools

dot-ai
Dot-ai is a machine learning library designed to simplify the process of building and deploying AI models. It provides a wide range of tools and utilities for data preprocessing, model training, and evaluation. With Dot-ai, users can easily create and experiment with various machine learning algorithms without the need for extensive coding knowledge. The library is built with scalability and performance in mind, making it suitable for both small-scale projects and large-scale applications. Whether you are a beginner or an experienced data scientist, Dot-ai offers a user-friendly interface to streamline your AI development workflow.

Riona-AI-Agent
Riona-AI-Agent is a versatile AI chatbot designed to assist users in various tasks. It utilizes natural language processing and machine learning algorithms to understand user queries and provide accurate responses. The chatbot can be integrated into websites, applications, and messaging platforms to enhance user experience and streamline communication. With its customizable features and easy deployment, Riona-AI-Agent is suitable for businesses, developers, and individuals looking to automate customer support, provide information, and engage with users in a conversational manner.

Auditor
TheAuditor is an offline-first, AI-centric SAST & code intelligence platform designed to find security vulnerabilities, track data flow, analyze architecture, detect refactoring issues, run industry-standard tools, and produce AI-ready reports. It is specifically tailored for AI-assisted development workflows, providing verifiable ground truth for developers and AI assistants. The tool orchestrates verifiable data, focuses on AI consumption, and is extensible to support Python and Node.js ecosystems. The comprehensive analysis pipeline includes stages for foundation, concurrent analysis, and final aggregation, offering features like refactoring detection, dependency graph visualization, and optional insights analysis. The tool interacts with antivirus software to identify vulnerabilities, triggers performance impacts, and provides transparent information on common issues and troubleshooting. TheAuditor aims to address the lack of ground truth in AI development workflows and make AI development trustworthy by providing accurate security analysis and code verification.

generator
ctx is a tool designed to automatically generate organized context files from code files, GitHub repositories, Git commits, web pages, and plain text. It aims to efficiently provide necessary context to AI language models like ChatGPT and Claude, enabling users to streamline code refactoring, multiple iteration development, documentation generation, and seamless AI integration. With ctx, users can create structured markdown documents, save context files, and serve context through an MCP server for real-time assistance. The tool simplifies the process of sharing project information with AI assistants, making AI conversations smarter and easier.

DesktopCommanderMCP
Desktop Commander MCP is a server that allows the Claude desktop app to execute long-running terminal commands on your computer and manage processes through Model Context Protocol (MCP). It is built on top of MCP Filesystem Server to provide additional search and replace file editing capabilities. The tool enables users to execute terminal commands with output streaming, manage processes, perform full filesystem operations, and edit code with surgical text replacements or full file rewrites. It also supports vscode-ripgrep based recursive code or text search in folders.

omniscient
Omniscient is an advanced AI Platform offered as a SaaS, empowering projects with cutting-edge artificial intelligence capabilities. Seamlessly integrating with Next.js 14, React, Typescript, and APIs like OpenAI and Replicate, it provides solutions for code generation, conversation simulation, image creation, music composition, and video generation.

Zentara-Code
Zentara Code is an AI coding assistant for VS Code that turns chat instructions into precise, auditable changes in the codebase. It is optimized for speed, safety, and correctness through parallel execution, LSP semantics, and integrated runtime debugging. It offers features like parallel subagents, integrated LSP tools, and runtime debugging for efficient code modification and analysis.

Vodalus-Expert-LLM-Forge
Vodalus Expert LLM Forge is a tool designed for crafting datasets and efficiently fine-tuning models using free open-source tools. It includes components for data generation, LLM interaction, RAG engine integration, model training, fine-tuning, and quantization. The tool is suitable for users at all levels and is accompanied by comprehensive documentation. Users can generate synthetic data, interact with LLMs, train models, and optimize performance for local execution. The tool provides detailed guides and instructions for setup, usage, and customization.

conar
Conar is an AI-powered open-source project designed to simplify database interactions. It is built for PostgreSQL with plans to support other databases in the future. Users can securely store their connections in the cloud and leverage AI assistance to write and optimize SQL queries. The project emphasizes security, multi-database support, and AI-powered features to enhance the database management experience. Conar is developed using React with TypeScript, Electron, and various other technologies to provide a comprehensive solution for database management.

llmgateway
The llmgateway repository is a tool that provides a gateway for interacting with various LLM (Large Language Model) models. It allows users to easily access and utilize pre-trained language models for tasks such as text generation, sentiment analysis, and language translation. The tool simplifies the process of integrating LLMs into applications and workflows, enabling developers to leverage the power of state-of-the-art language models for various natural language processing tasks.

CortexON
CortexON is an open-source, multi-agent AI system designed to automate and simplify everyday tasks. It integrates specialized agents like Web Agent, File Agent, Coder Agent, Executor Agent, and API Agent to accomplish user-defined objectives. CortexON excels at executing complex workflows, research tasks, technical operations, and business process automations by dynamically coordinating the agents' unique capabilities. It offers advanced research automation, multi-agent orchestration, integration with third-party APIs, code generation and execution, efficient file and data management, and personalized task execution for travel planning, market analysis, educational content creation, and business intelligence.

BMAD-METHOD
BMAD-METHODβ’ is a universal AI agent framework that revolutionizes Agile AI-Driven Development. It offers specialized AI expertise across various domains, including software development, entertainment, creative writing, business strategy, and personal wellness. The framework introduces two key innovations: Agentic Planning, where dedicated agents collaborate to create detailed specifications, and Context-Engineered Development, which ensures complete understanding and guidance for developers. BMAD-METHODβ’ simplifies the development process by eliminating planning inconsistency and context loss, providing a seamless workflow for creating AI agents and expanding functionality through expansion packs.

Auto_Jobs_Applier_AIHawk
Auto_Jobs_Applier_AIHawk is an AI-powered job search assistant that revolutionizes the job search and application process. It automates application submissions, provides personalized recommendations, and enhances the chances of landing a dream job. The tool offers features like intelligent job search automation, rapid application submission, AI-powered personalization, volume management with quality, intelligent filtering, dynamic resume generation, and secure data handling. It aims to address the challenges of modern job hunting by saving time, increasing efficiency, and improving application quality.

polyfire-js
Polyfire is an all-in-one managed backend for AI apps that allows users to build AI applications directly from the frontend, eliminating the need for a separate backend. It simplifies the process by providing most backend services in just a few lines of code. With Polyfire, users can easily create chatbots, transcribe audio files, generate simple text, manage long-term memory, and generate images. The tool also offers starter guides and tutorials to help users get started quickly and efficiently.

FunGen-AI-Powered-Funscript-Generator
FunGen is a Python-based tool that uses AI to generate Funscript files from VR and 2D POV videos. It enables fully automated funscript creation for individual scenes or entire folders of videos. The tool includes features like automatic system scaling support, quick installation guides for Windows, Linux, and macOS, manual installation instructions, NVIDIA GPU setup, AMD GPU acceleration, YOLO model download, GUI settings, GitHub token setup, command-line usage, modular systems for funscript filtering and motion tracking, performance and parallel processing tips, and more. The project is still in early development stages and is not intended for commercial use.

Cerebr
Cerebr is an intelligent AI assistant browser extension designed to enhance work efficiency and learning experience. It integrates powerful AI capabilities from various sources to provide features such as smart sidebar, multiple API support, cross-browser API configuration synchronization, comprehensive Q&A support, elegant rendering, real-time response, theme switching, and more. With a minimalist design and focus on delivering a seamless, distraction-free browsing experience, Cerebr aims to be your second brain for deep reading and understanding.
For similar tasks

nlp-llms-resources
The 'nlp-llms-resources' repository is a comprehensive resource list for Natural Language Processing (NLP) and Large Language Models (LLMs). It covers a wide range of topics including traditional NLP datasets, data acquisition, libraries for NLP, neural networks, sentiment analysis, optical character recognition, information extraction, semantics, topic modeling, multilingual NLP, domain-specific LLMs, vector databases, ethics, costing, books, courses, surveys, aggregators, newsletters, papers, conferences, and societies. The repository provides valuable information and resources for individuals interested in NLP and LLMs.

adata
AData is a free and open-source A-share database that focuses on transaction-related data. It provides comprehensive data on stocks, including basic information, market data, and sentiment analysis. AData is designed to be easy to use and integrate with other applications, making it a valuable tool for quantitative trading and AI training.

PIXIU
PIXIU is a project designed to support the development, fine-tuning, and evaluation of Large Language Models (LLMs) in the financial domain. It includes components like FinBen, a Financial Language Understanding and Prediction Evaluation Benchmark, FIT, a Financial Instruction Dataset, and FinMA, a Financial Large Language Model. The project provides open resources, multi-task and multi-modal financial data, and diverse financial tasks for training and evaluation. It aims to encourage open research and transparency in the financial NLP field.

hezar
Hezar is an all-in-one AI library designed specifically for the Persian community. It brings together various AI models and tools, making it easy to use AI with just a few lines of code. The library seamlessly integrates with Hugging Face Hub, offering a developer-friendly interface and task-based model interface. In addition to models, Hezar provides tools like word embeddings, tokenizers, feature extractors, and more. It also includes supplementary ML tools for deployment, benchmarking, and optimization.

text-embeddings-inference
Text Embeddings Inference (TEI) is a toolkit for deploying and serving open source text embeddings and sequence classification models. TEI enables high-performance extraction for popular models like FlagEmbedding, Ember, GTE, and E5. It implements features such as no model graph compilation step, Metal support for local execution on Macs, small docker images with fast boot times, token-based dynamic batching, optimized transformers code for inference using Flash Attention, Candle, and cuBLASLt, Safetensors weight loading, and production-ready features like distributed tracing with Open Telemetry and Prometheus metrics.

CodeProject.AI-Server
CodeProject.AI Server is a standalone, self-hosted, fast, free, and open-source Artificial Intelligence microserver designed for any platform and language. It can be installed locally without the need for off-device or out-of-network data transfer, providing an easy-to-use solution for developers interested in AI programming. The server includes a HTTP REST API server, backend analysis services, and the source code, enabling users to perform various AI tasks locally without relying on external services or cloud computing. Current capabilities include object detection, face detection, scene recognition, sentiment analysis, and more, with ongoing feature expansions planned. The project aims to promote AI development, simplify AI implementation, focus on core use-cases, and leverage the expertise of the developer community.

spark-nlp
Spark NLP is a state-of-the-art Natural Language Processing library built on top of Apache Spark. It provides simple, performant, and accurate NLP annotations for machine learning pipelines that scale easily in a distributed environment. Spark NLP comes with 36000+ pretrained pipelines and models in more than 200+ languages. It offers tasks such as Tokenization, Word Segmentation, Part-of-Speech Tagging, Named Entity Recognition, Dependency Parsing, Spell Checking, Text Classification, Sentiment Analysis, Token Classification, Machine Translation, Summarization, Question Answering, Table Question Answering, Text Generation, Image Classification, Image to Text (captioning), Automatic Speech Recognition, Zero-Shot Learning, and many more NLP tasks. Spark NLP is the only open-source NLP library in production that offers state-of-the-art transformers such as BERT, CamemBERT, ALBERT, ELECTRA, XLNet, DistilBERT, RoBERTa, DeBERTa, XLM-RoBERTa, Longformer, ELMO, Universal Sentence Encoder, Llama-2, M2M100, BART, Instructor, E5, Google T5, MarianMT, OpenAI GPT2, Vision Transformers (ViT), OpenAI Whisper, and many more not only to Python and R, but also to JVM ecosystem (Java, Scala, and Kotlin) at scale by extending Apache Spark natively.

scikit-llm
Scikit-LLM is a tool that seamlessly integrates powerful language models like ChatGPT into scikit-learn for enhanced text analysis tasks. It allows users to leverage large language models for various text analysis applications within the familiar scikit-learn framework. The tool simplifies the process of incorporating advanced language processing capabilities into machine learning pipelines, enabling users to benefit from the latest advancements in natural language processing.
For similar jobs

weave
Weave is a toolkit for developing Generative AI applications, built by Weights & Biases. With Weave, you can log and debug language model inputs, outputs, and traces; build rigorous, apples-to-apples evaluations for language model use cases; and organize all the information generated across the LLM workflow, from experimentation to evaluations to production. Weave aims to bring rigor, best-practices, and composability to the inherently experimental process of developing Generative AI software, without introducing cognitive overhead.

LLMStack
LLMStack is a no-code platform for building generative AI agents, workflows, and chatbots. It allows users to connect their own data, internal tools, and GPT-powered models without any coding experience. LLMStack can be deployed to the cloud or on-premise and can be accessed via HTTP API or triggered from Slack or Discord.

VisionCraft
The VisionCraft API is a free API for using over 100 different AI models. From images to sound.

kaito
Kaito is an operator that automates the AI/ML inference model deployment in a Kubernetes cluster. It manages large model files using container images, avoids tuning deployment parameters to fit GPU hardware by providing preset configurations, auto-provisions GPU nodes based on model requirements, and hosts large model images in the public Microsoft Container Registry (MCR) if the license allows. Using Kaito, the workflow of onboarding large AI inference models in Kubernetes is largely simplified.

PyRIT
PyRIT is an open access automation framework designed to empower security professionals and ML engineers to red team foundation models and their applications. It automates AI Red Teaming tasks to allow operators to focus on more complicated and time-consuming tasks and can also identify security harms such as misuse (e.g., malware generation, jailbreaking), and privacy harms (e.g., identity theft). The goal is to allow researchers to have a baseline of how well their model and entire inference pipeline is doing against different harm categories and to be able to compare that baseline to future iterations of their model. This allows them to have empirical data on how well their model is doing today, and detect any degradation of performance based on future improvements.

tabby
Tabby is a self-hosted AI coding assistant, offering an open-source and on-premises alternative to GitHub Copilot. It boasts several key features: * Self-contained, with no need for a DBMS or cloud service. * OpenAPI interface, easy to integrate with existing infrastructure (e.g Cloud IDE). * Supports consumer-grade GPUs.

spear
SPEAR (Simulator for Photorealistic Embodied AI Research) is a powerful tool for training embodied agents. It features 300 unique virtual indoor environments with 2,566 unique rooms and 17,234 unique objects that can be manipulated individually. Each environment is designed by a professional artist and features detailed geometry, photorealistic materials, and a unique floor plan and object layout. SPEAR is implemented as Unreal Engine assets and provides an OpenAI Gym interface for interacting with the environments via Python.

Magick
Magick is a groundbreaking visual AIDE (Artificial Intelligence Development Environment) for no-code data pipelines and multimodal agents. Magick can connect to other services and comes with nodes and templates well-suited for intelligent agents, chatbots, complex reasoning systems and realistic characters.