thehardwarestore.ai

This is an MCP (Model Context Protocol) server implementation that provides LLMs with MySQL database access. The server exposes a single `mysql_query` tool for executing SQL queries and resources for listing tables and column metadata. It supports both stdio and HTTP transport modes, the latter with bearer token authentication. Key features include multi-database mode (querying across schemas without reconnection), schema-specific write permissions (INSERT/UPDATE/DELETE/DDL per database), SSL/TLS with mTLS, Unix socket connections, and a sophisticated PII redaction system that combines column-name heuristics with regex value scanning and Luhn-verified credit card detection. The architecture is monolithic: a single Express server (or stdio process) manages a mysql2 connection pool and routes all MCP protocol requests through zod-validated schemas. The codebase is well-tested with unit, integration, and end-to-end test suites, and demonstrates careful engineering in areas like query parsing (using node-sql-parser), permission enforcement, and secure defaults (write operations disabled by default).

Sunone Aimbot is an AI-powered aimbot for first-person shooter games that uses YOLO models to detect players and heads in real-time screen captures. The system captures frames via MSS, BetterCam, or OBS, processes them with Ultralytics YOLO, identifies targets (prioritizing heads unless disabled), calculates mouse movement to aim at targets, and optionally shoots automatically. It features a modular architecture with separate threads for capture, visualization, overlay, shooting, and hotkey monitoring. A helper API and React-based UI provide configuration management, model training/exporting, and testing capabilities. The aimbot supports multiple input methods including standard mouse, GHUB, Razer, and Arduino devices.

ColossalAI is a comprehensive distributed training and inference framework for large-scale deep learning models, providing multiple parallelism strategies (data, tensor, pipeline, sequence, mixture-of-experts), ZeRO memory optimization, automatic parallelization via FX tracing, and high-performance custom CUDA/Triton kernels. The architecture is library-based with a plugin-style booster for orchestrating training and inference, a shardformer for model-level parallelism policies, and a legacy subsystem for older APIs. It includes application-level tools: ColossalChat for RLHF (PPO, DPO, GRPO), ColossalQA for retrieval-augmented question answering, ColossalEval for LLM evaluation with GPT judges, and Colossal-LLaMA for domain-specific LLM training. The codebase is actively maintained with recent commits, but has notable technical drift due to outdated dependency pins in some examples and a large legacy namespace that coexists with newer implementations.

SillyTavern is a full-stack web application (Node.js/Express backend, jQuery/Webpack frontend) that serves as a highly customizable frontend for interacting with large language models (LLMs) for roleplaying and chat. It supports dozens of AI backends (OpenAI, Anthropic, Kobold, Ollama, vLLM, etc.) via streaming text and chat completions, and provides an extensive plugin/extension system for TTS, translation, image generation, vector search, and more. The application features a sophisticated macro engine (Chevrotain-based CST parser) for dynamic prompt templating, a slash command framework with typed arguments and autocomplete, and a rich UI with themes, backgrounds, character management, and branching chat history. It is designed for power users who want fine-grained control over prompts, model parameters, and UI behavior, and includes multi-user support with authentication, secrets management, and per-user data isolation.

garak is a CLI tool and Python library for automated red-teaming and vulnerability scanning of large language models (LLMs). It systematically probes models with adversarial inputs (jailbreaks, prompt injections, encoding attacks, etc.) and uses detectors to classify model responses for safety failures. It supports multiple model backends (OpenAI, Anthropic, HuggingFace, etc.) and generates structured reports with severity scoring. The system follows a modular plugin architecture with base classes for probes, detectors, generators, harnesses, evaluators, and buffs. Plugins are dynamically loaded and configured via a hierarchical config system. The default harness runs probes with their associated detectors, while a cross-product harness allows all probes against all detectors. Results are logged as JSONL and can be visualized via a React-based web UI (garak-report) that displays DEFCON-level severity, calibration Z-scores, and technique-intent matrices. While primarily an application, garak incorporates significant research elements: it implements state-of-the-art attack techniques (GCG, AutoDAN, BEAST, TAP) and includes curated datasets of adversarial prompts and calibration data. The codebase serves both as a practical security tool and as a research platform for LLM vulnerability assessment.

The AIMLInterviews repository is primarily an interview preparation tool that centers around an MCP (Model Context Protocol) server. This server turns any MCP-compatible AI assistant into a spoiler-free interview coach by providing tools to list problems, give progressive hints, review answers, and generate learning or company-specific preparation plans. The server dynamically builds an in-memory catalog by scanning markdown files in the src/ and cn/ directories, extracting problems and sections based on heading patterns. Beyond the server, the repository contains extensive educational content including markdown guides, Jupyter notebooks for ML algorithm implementations, and solution code with tests, all aimed at AI/ML interview readiness.

Activeloop's DeepLake is a production-grade, multi-vector database engine for AI data. At its core, it is a columnar, chunked, compressed storage system for tensors (multi-dimensional arrays) with native support for embeddings, images, video, text, and other complex AI data types. It exposes a Python library for dataset management, ingestion (COCO, Labelbox, CSV, Parquet), version control, and integration with PyTorch/TensorFlow/MMDetection. A high-performance C++ backend provides lazy NumPy-like array operations (nd::array), a composable async framework (async::promise), and a Tensor Query Language (TQL). The most distinctive component is a PostgreSQL extension (pg_deeplake) that allows SQL access to DeepLake datasets via custom table and index access methods, supporting vector similarity search (cosine, BM25) and hybrid search. Query execution is delegated to DuckDB through a custom scan node, enabling efficient analytical queries. The extension also includes WAL-based DDL replication across instances. This is primarily an application (a database system), with substantial research-oriented features such as medical image formats, compression codecs, and TPC-H benchmarking.

Peekaboo is a mature macOS desktop automation toolkit that provides a CLI, Mac app, and MCP server for screen capture, UI element detection, input synthesis, window management, and AI agent integration. The architecture is modular: a Swift CLI (peekaboo) exposes ~33 commands for interaction, system control, and AI agent orchestration; a Mac app provides a menu bar interface, session management, and visualizer overlays; a bridge daemon (PeekabooBridge) enables secure remote automation via a versioned socket protocol with operation allowlisting. The MCP server exposes native automation tools to AI clients (Claude, Cursor, etc.) via stdio transport. The agent runtime (PeekabooAgentService) supports multiple AI providers (OpenAI, Anthropic, Ollama, etc.) with streaming, tool calling, and session persistence. The codebase is written in Swift 6.2 with strict concurrency, extensive unit/integration tests, and a focus on safety (fail-closed target validation, honest effect reporting). It is not a data research project; it is a production-grade application for macOS automation.

This repository contains a minimal coding agent designed to work with local Ollama models. The agent operates in a loop, processing user requests by inspecting and modifying the workspace through a set of structured tools (file operations, shell commands, etc.). It implements six core components: live repo context collection, prompt shaping with cache reuse, structured tools with validation and permissions, context reduction and output management, transcript and memory persistence, and bounded delegation to subagents. The agent is implemented in a single Python file (`mini_coding_agent.py`) and is intended to be run via a CLI entry point. It requires an Ollama server running with a compatible model (default: qwen3.5:4b). The code is clean, well-structured, and demonstrates thoughtful agent design patterns, making it a useful reference for building similar agents.

AI Vocabulary Builder is a full-stack web application (FastAPI backend, Vue.js frontend) that uses LLM APIs (OpenAI, Gemini, Anthropic, DeepSeek) to help users build and learn English vocabulary. The backend exposes REST APIs for translating text, extracting rare words, managing a vocabulary store (TinyDB), generating stories and quizzes from learned words, and exporting to Anki/CSV. The frontend provides an intuitive single-page interface with build, learn (words list, quiz, story) and settings views. The architecture follows a modular monolith with clear separation of concerns: `builder` for vocabulary extraction, `learn` for quiz/story features, `system` for settings and model configuration, and `infras` for persistence and AI model abstraction. The codebase is well-structured with comprehensive unit tests, CI/CD via GitHub Actions, and rigorous linting/formatting (ruff, mypy).

Clarvis AI is a Docker-based orchestration system that combines OpenClaw, claw3d, and curaengine-slicer-api to create an AI-powered 3D printing assistant accessible via Telegram, Discord, or WhatsApp. Users can interact through natural language to generate 3D models from text/images, search existing models, slice them to G-code, and send them to compatible printers. The system features a two-service architecture: a gateway handling AI and chat integrations, and a slicer service providing REST API access to CuraEngine for model slicing. The setup process is automated via a comprehensive bash script that builds Docker images, runs interactive configuration wizards for both OpenClaw and claw3d components, and starts all services. A notable reusable component is the Node.js-based configuration script for claw3d, which uses @clack/prompts to create a polished terminal user interface for gathering settings and outputting JSON configuration. This script exemplifies strong CLI tool design with clear separation of concerns, error handling, and adaptability for reuse in other projects.

This repository is a comprehensive knowledge base and reference implementation for Claude Code best practices, curated by Shayan Rais. It is not a standalone application but rather a living documentation and configuration library that demonstrates how to effectively use Claude Code CLI through agents, skills, commands, hooks, and workflows. The core architecture follows a Command → Agent → Skill orchestration pattern, with working examples such as a weather reporter system and a structured RPI (Research-Plan-Implement) development workflow. The repository includes reusable configuration patterns (YAML frontmatter schemas for agents and skills), a cross-platform Python hook script for lifecycle events, detailed changelogs that track drift against official Claude Code documentation, and extensive reference guides covering settings, environment variables, MCP servers, and startup flags. While primarily a documentation and reference project, it contains runnable Claude Code configurations that can be directly adopted or adapted by other projects.

This repository is a structured, comprehensive AI engineering curriculum spanning 20 phases and over 500 lessons, from math foundations and ML fundamentals to deep learning, computer vision, NLP, speech, transformers, generative AI, reinforcement learning, LLMs from scratch, agent engineering, multi-agent systems, production infrastructure, and ethics/safety. It is an educational resource, not a production application or data research project. The code consists of self-contained pedagogical implementations (primarily Python, with some TypeScript, Rust, and Julia) that demonstrate core algorithms from scratch—such as attention mechanisms, BPE tokenization, diffusion models, RLHF, and agent loops—using synthetic data and deterministic stubs. Capstone projects include small web servers (Hono/TypeScript) and test harnesses. The curriculum is actively maintained with CI tooling, certification prep materials, and translation support. While the code is simplified for learning, it exhibits clean patterns, consistent lesson structure, and testing practices that make individual components (e.g., tool registries, state machines, evaluation harnesses) reusable in other contexts.

Tabby is a self-hosted AI coding assistant that provides code completion, chat, and code search capabilities through multiple interfaces: a web dashboard (Next.js/React), IDE plugins (VS Code, IntelliJ, Eclipse, Vim), and a Language Server Protocol (LSP) agent. The backend is primarily written in Rust, using Axum for HTTP services, Tantivy for indexing, and llama.cpp for local model inference. It supports enterprise features like SSO (OAuth, LDAP), team management, access policies, and background job scheduling for repository indexing, web crawling, and third-party integration (GitHub/GitLab). The system is designed to be self-contained, running without external cloud dependencies, and can operate on consumer-grade GPUs. The architecture follows a monorepo pattern with Rust crates for core services (inference, indexing, git operations, download) and TypeScript/JavaScript for the agent and UI. The web dashboard uses GraphQL (Juniper) for API communication, while IDE plugins communicate via LSP. Data flows include: code completion requests from editors → agent → backend model server → response with postprocessing; chat queries → retrieval-augmented generation (RAG) pipeline using indexed code and documentation; and background jobs for syncing repositories, crawling web docs, and indexing commits/issues/PRs. External dependencies include SQLite (via SQLx), llama.cpp, tree-sitter, and various cloud provider APIs for OAuth. The codebase demonstrates strong engineering practices with modular design, extensive testing (unit tests, golden tests), and reusable patterns such as a background job abstraction, config merging system, and a postprocessing pipeline for code completions. However, the polyglot nature (Rust, TypeScript, Java, Kotlin) and multiple client implementations introduce maintenance complexity and potential drift. The repository is actively maintained with frequent releases and a large community (33k+ stars).

NeoPass is a browser extension designed to assist students during online exams by bypassing restrictions (tab switching, pasting, screenshare) and providing AI-powered answer assistance. It employs a Manifest V3 architecture with a background service worker, content scripts injected into exam platforms, and a popup UI for configuration. Key features include automatic code typing, MCQ solving, a stealth-mode chatbot, and anti-detection measures to avoid identification by exam portals. The extension supports both a free mode (requiring user-configured API keys) and a Pro mode via a managed backend service.

Vanna is an open-source Python framework that generates SQL queries from natural language using retrieval-augmented generation (RAG). It provides a modular agent architecture with a core `Agent` class that orchestrates LLM interactions, tool execution, and rich UI component streaming. The system supports multiple LLM providers (OpenAI, Anthropic, Gemini, Ollama, etc.) and vector store backends (ChromaDB, FAISS, Qdrant, Pinecone, etc.) for storing and retrieving training data (question-SQL pairs, DDL, documentation). It includes a comprehensive evaluation framework for comparing agent variants, a legacy Flask API for backward compatibility, and a modern Lit-based web component frontend that renders rich components (tables, charts, cards, progress bars) via SSE streaming. The architecture is highly extensible with dependency injection for lifecycle hooks, LLM middlewares, error recovery strategies, context enrichers, conversation filters, and observability providers. Key entry points include the `Agent.send_message()` async generator, the `ToolRegistry` for tool management, and server factories for Flask and FastAPI. The system relies on external dependencies for LLM APIs, vector databases, and SQL databases, all configured as optional extras. The codebase demonstrates strong engineering practices with clean abstractions, though it carries significant legacy code from a previous version and some placeholder implementations (e.g., MD5-based embeddings in Qdrant).

MagenticLite (Magentic-UI 2.0) is a full-stack, open-source agentic application from Microsoft AI Frontiers that pairs an orchestrator agent (MagenticBrain / OmniAgent) with a browser-use sub-agent (Fara) to automate web research, form filling, file management, and code execution in real time. The architecture comprises a Python/FastAPI backend with WebSocket-based streaming, a React/TypeScript frontend (Vite, Tailwind, Zustand, TanStack Query), and a Quicksand VM sandbox for isolated browser and code execution. The system is designed for local-first, single-user operation with a CLI entry point (`magentic-ui`) and optional Docker-based deployment. The application emphasizes human-in-the-loop control: approval policies for bash and file commands, pause/resume, mid-run user interjection, browser takeover mode, and folder-mount consent dialogs. It supports two agent roles (orchestrator and web surfer) with configurable endpoint providers and max-round caps. The frontend offers session management, chat view with rich message rendering (CUA browser actions, code execution, file preview, reasoning traces), and a real-time browser viewer via VNC. The codebase demonstrates strong engineering practices: a sandbox abstraction with host/guest path translation, secure token-based authentication, host-header allowlisting, path traversal validation, and a modular tool registry. It includes extensive unit and integration tests covering agent state persistence, compaction, command classification, and sandbox lifecycle. Despite being labeled a research prototype (v0.2.2, alpha), the repository shows active maintenance, clean architecture, and several reusable patterns that could be extracted into independent projects.

Cookiecutter Data Science (CCDS) is a CLI tool that generates standardized, opinionated project scaffolds for data science work. It wraps the cookiecutter templating engine with custom prompting logic that supports nested configuration choices (e.g., cloud storage options with sub-fields for bucket names), and post-generation hooks that dynamically write dependency files in multiple formats (requirements.txt, pyproject.toml, environment.yml, Pipfile, pixi.toml), configure linting/formatting tools (ruff or flake8+black+isort), set up testing frameworks (pytest/unittest), and scaffold code modules with boilerplate for data processing, feature engineering, modeling, and visualization. The tool is designed to be run via the `ccds` command, which defaults to the DrivenData template repository and the installed version of the template. The codebase demonstrates solid software engineering: it monkey-patches cookiecutter's internals in a controlled way to add functionality (prompting with sub-options, custom context file selection), provides a suite of reusable hook utilities for dependency management and custom config injection, and maintains extensive test coverage across multiple operating systems and environment managers (conda, virtualenv, pipenv, uv, pixi, poetry). The architecture is a thin CLI application that delegates to cookiecutter while extending it through monkey-patching and post-generation hooks. It is not a data research project itself but a tool for creating such projects.

The google/adk-go repository is a production-grade, open-source Go framework for building, orchestrating, and deploying multi-agent AI systems. It provides a comprehensive set of abstractions including agents, workflows, tool integrations, model backends (Gemini, OpenAI, Apigee), session management, artifact storage, and human-in-the-loop (HITL) support. The architecture centers around a workflow engine that supports graph-based execution with nodes, edges, retry, concurrency, and dynamic branching. It also implements agent-to-agent (A2A) and Model Context Protocol (MCP) for inter-agent communication. The framework is designed to be deployed via REST API, WebSocket, SSE, or as a console application, and includes launchers for Google Cloud Run and Vertex AI Agent Engine. While primarily an application framework, it also includes telemetry and analytics plugins for observability. The codebase is well-structured with extensive unit and integration tests, but some internal packages and experimental features (e.g., OpenAI model adapter) indicate ongoing development and potential for interface drift.