thehardwarestore.ai

AgentScope is a full-stack, production-grade multi-agent orchestration platform. The core library (`src/agentscope/`) provides a FastAPI-based agent service with CRUD endpoints for agents, sessions, credentials, channels, knowledge bases, schedules, and SOPs. It features a modular middleware onion pattern for agent lifecycle hooks (reply, reasoning, acting, tool execution), a pluggable storage abstraction (Redis, SQL with Alembic migrations, S3 blob store), and a message bus (in-memory or Redis) for inter-session communication and distributed coordination. The system supports real-time voice (WebRTC, DashScope/OpenAI/Gemini/xAI), RAG pipelines with document parsing and vector stores (Qdrant, Milvus, MongoDB, Elasticsearch), channel integrations (Feishu, DingTalk, Discord), and sandboxed workspace backends (Docker, Kubernetes, E2B, Daytona, Apple Containers, Bubblewrap, OpenSandbox). A full React/TypeScript web UI (`examples/web_ui/frontend`) provides chat, channel management, schedule calendar, knowledge base browsing, and MCP hub browsing. Additionally, a terminal console and a goal-oriented pipeline are provided for developer workflows. The framework emphasizes transparency, controllability, and separation between agent logic and infrastructure, supporting multi-agent collaboration, human-in-the-loop permissions, and long-term memory via ReMe and mem0 middleware.

This is a LangGraph-based web research assistant that runs fully locally. It accepts a research topic, then enters a loop: an LLM (Ollama or LMStudio) generates a web search query, a configurable search API (DuckDuckGo, Tavily, Perplexity, or SearXNG) fetches results, the same LLM summarizes the findings and reflects on knowledge gaps to generate follow-up queries. After a configurable number of iterations, it produces a final markdown summary with deduplicated source citations. The architecture is a clean state graph with six nodes and conditional routing, all orchestrated via LangGraph's compile and run mechanism. It is deployed as a LangGraph dev server or via Docker. The codebase demonstrates solid LangGraph patterns, proper separation of concerns (configuration, state, utilities, prompts, graph definition), and a smart abstraction for switching between JSON mode and tool calling for structured LLM output. Notable craft includes the `generate_search_query_with_structured_output` helper that cleanly handles fallback and the `ChatLMStudio` adapter for LMStudio's OpenAI-compatible API.

napari-chatgpt (Omega) is an LLM-powered autonomous agent designed as a napari plugin for interactive image analysis. It enables users to interact with the napari viewer via natural language through a chat interface, either embedded in napari or via a web-based UI. The system processes user commands by leveraging LLMs (via LiteMind) to select and execute appropriate tools for tasks such as image loading, segmentation, denoising, widget creation, viewer control, web search, and code execution. The architecture centers around a plugin-contributed dock widget that launches a chat interface, which communicates with a FastAPI/WebSocket backend. The backend hosts the Omega agent, which uses a modular tool system where each tool (e.g., for file operations, segmentation, or web requests) inherits from a base class and is responsible for executing specific actions. The agent can iteratively refine its actions through dialogue, enabling complex workflows like 'segment nuclei and show measurement statistics'. Key external dependencies include napari (>=0.5), LiteMind, LLM provider libraries (OpenAI, Anthropic, Google), FastAPI, Qt bindings, and scientific libraries like scikit-image, Cellpose, and StarDist.

A comprehensive, actively maintained collection of IDA Pro plugins, scripts, and tooling authored by Willi Ballenthin (Hex-Rays). The repository spans multiple domains: UI enhancement plugins (oplog, bookmark_hints, colorize_calls, navband_visited, tag_func, hint_calls), analysis utilities (flirt-data-pack, vtloader, global_struct_dissector), a CLI binary inspector (idals), and a modern LLM-integrated reverse engineering agent (ida-codemode) consisting of a sandbox, portable API, AI agent, and evaluation framework. The core idawilli package provides reusable syntax and lexing utilities for IDA's tagged-line output. The codebase is well-engineered with modern Python practices: Pydantic models, type hints, uv workspace management, Rich CLI interfaces, and comprehensive pytest suites. While primarily an application for IDA Pro enhancement, it also includes data/research elements in the form of LLM benchmarking evaluations (c2_extraction) and systematic test data. The sandbox isolation pattern, evaluator framework, and tagged-line parsing utilities are especially clean and potentially reusable outside this repository.

ChatTTS is a generative speech model application designed specifically for dialogue scenarios, functioning as a Text-to-Speech (TTS) library with integrated serving infrastructure. The core logic resides in the ChatTTS package, where `ChatTTS/core.py` defines the main inference interface. The architecture combines a GPT-based language model (`ChatTTS/model/gpt.py`) for token generation, a DVAE (`ChatTTS/model/dvae.py`) for audio compression, and Vocos as a vocoder. The system supports multiple speakers, prosodic control (laughter, pauses), and text normalization for Chinese and English. Deployment is handled through multiple entry points: a FastAPI-based API server (`examples/api/main.py`), a Gradio WebUI (`examples/web/webui.py`), and CLI tools (`examples/cmd/run.py`). A significant engineering highlight is the integration of vLLM (`ChatTTS/model/velocity/`) to optimize inference throughput for the GPT component. The repository includes robust asset management (`ChatTTS/utils/dl.py`) for model weights with SHA256 verification and ONNX export capabilities (`examples/onnx/exporter.py`) for cross-platform deployment. While the underlying model is research-grade (trained on 100k+ hours of audio), the repository structure prioritizes application delivery over experimental research. It provides a stable library interface with clear separation between model logic, audio processing (`tools/audio/`), and serving layers. The codebase demonstrates high craftsmanship in handling stochastic generation reproducibility (`tools/seeder/ctx.py`) and speaker embedding management (`ChatTTS/model/speaker.py`), making it a production-ready TTS solution rather than a raw research notebook collection.

EvoMap Evolver is a self-evolving AI agent engine built as a Node.js >=22.12 CLI daemon. It runs a genome-evolution loop: scans session memory/logs, extracts signals, selects 'Genes' (prompt/strategy patches) and 'Capsules' (validated skill bundles) from a local JSON/JSONL asset store, generates GEP-framed prompts for coding agents (Claude Code, Codex, Cursor, Gemini CLI, opencode, Kiro), executes those sessions, and records outcomes in a memory graph to adapt future selections. The system solidifies successful patterns into new reusable assets, auto-distills failure patterns and SKILL.md files into Genes/Capsules, and can open PRs or run validation sandboxes against candidate changes. It also ships an LLM proxy (Anthropic/OpenAI/Gemini/Vertex/Ollama routes with trace encryption and token-savings attribution), an ATP (Agent Transaction Protocol) marketplace for buying/completing agent tasks with auto-buyer and auto-deliver, a validation daemon for decentralized task verification, a local Web UI dashboard, and an experiment runner for A/B comparing evolution strategies. Hub synchronization (SSE event delivery, mailbox sync, OAuth device login) connects nodes to the evomap.ai network, but the system is designed to degrade gracefully into fully offline solo mode.

Chef is a production-grade AI agent that generates full-stack web applications through an interactive chat interface. It integrates a multi-provider LLM orchestration layer (Anthropic, OpenAI, Google, xAI) with a WebContainer-based sandbox to run generated code in the browser. The system allows users to chat with an agent that can create, edit, view, and deploy code to the Convex backend platform. It provides a code editor (CodeMirror), file tree, terminal, live preview, and sharing/cloning features. The architecture is a monolith with a Remix frontend, Convex backend for persistence and real-time updates, and a custom agent loop (chef-agent) that manages context, tool execution, and message streaming. The repository includes a CLI tool (chefshot) for headless generation and a test-kitchen for automated evals.

GEM is a Gym-like framework for training and evaluating agentic LLMs via reinforcement learning. It provides a diverse set of environments (games, math, code, QA, etc.) that can be used to train LLMs to interact with tools, solve problems, and make sequential decisions. The framework features a modular design with composable wrappers for observation modification, tool integration, and episode tracking, along with vectorized environments for parallel execution. It supports integration with multiple RL training frameworks (Oat, Verl, Tinker, OpenRLHF, RL2) through example scripts, making it a versatile tool for LLM agent research.

AutoGen is a multi-agent AI framework originally from Microsoft Research, now in maintenance mode and succeeded by Microsoft Agent Framework. The codebase is a large monorepo containing Python packages (autogen-core, autogen-agentchat, autogen-ext, autogen-studio, agbench) and a .NET implementation (Microsoft.AutoGen.*), with Python as the primary language. The architecture is layered: Core provides event-driven agent runtime, message passing, and distributed infrastructure via gRPC; AgentChat offers higher-level multi-agent teams and patterns; Extensions integrate external services (OpenAI, Azure, MCP, GraphRAG, etc.); Studio is a FastAPI web UI with a Gatsby frontend for no-code agent prototyping. Key entry points include AssistantAgent, group chat managers, and various team orchestrators. The system relies heavily on LLM clients, Pydantic models, gRPC for distributed runtimes, and OpenTelemetry for tracing. Despite the maintenance mode status, the code shows solid engineering with clear separation of concerns, extensive test suites, and well-structured packages. However, the ecosystem is in transition, with active development shifted to the successor framework.

PageEyes Agent is a production-grade Python framework for natural-language-driven UI automation, published on PyPI as `page-eyes` (v1.3.9). It provides LLM agents that perceive screens and execute actions (click, input, swipe, assert) across Web (Playwright), Android (ADB), iOS (WebDriverAgent), HarmonyOS (hdc), and Electron (CDP). The core architecture separates a PlanningAgent that decomposes user instructions into atomic steps from per-platform execution agents that call tools through Pydantic AI's tool-calling framework. Screen perception is delegated either to a vision-language model in lightweight mode or to the bundled OmniParser2 service in full mode. Each run produces a self-contained HTML report with step logs, screenshots, element bounding-box overlays, and video, which can be uploaded to COS or MinIO. The repo is hybrid: it is primarily an application framework but embeds a significant ML-serving sub-project, OmniParser2, which is a FastAPI microservice running PaddleOCR for text detection, a fine-tuned YOLOv11n for icon detection, a LoRA-fine-tuned Florence-2 model for icon captioning, and a YOLO overlay detector for popups/loading states, with optional Milvus-based image caching. Model weights and tokenizer artifacts (including a ~96k-token BPE merges file) are committed to the repository, and the docs include detailed articles on Florence-2 LoRA fine-tuning and YOLO overlay detection, giving the repo a data-research flavor alongside its application character. The codebase shows genuine engineering skill: a generic Device abstraction with factory methods, a storage strategy pattern (COS/MinIO/Base64), a reusable skills system (e.g., gui-popup-handler), and an agent loop with planning/execution/reflection separation. CI/CD, tests, a changelog, and mkdocs documentation are present. Weaknesses include heavy ML dependencies with override conflicts, a committed binary blob (yadb), code duplication between the main package and OmniParser2, and coupling to Tencent-internal infrastructure (mirror URLs, email addresses, platform names), which limits external portability.

This repository provides a Python library for converting web pages into text optimized for Large Language Model (LLM) input. It fetches HTML content using Playwright (headless browser) and processes it to extract meaningful text while preserving structural information like tables, links, and images in a text format. The core processing logic converts HTML tables to markdown, handles image and link preservation (or removal), and strips unnecessary tags (script, style) to reduce noise. The library is designed as a preprocessing step before feeding web content to LLMs for tasks such as data extraction or summarization. It includes three main modules: HTML fetching, HTML processing, and a combined convenience function.

This repository provides a template for building and deploying an AI agent using the ElizaOS framework on the Nosana decentralized compute network. It includes the necessary configuration files for containerization (Dockerfile), dependency management (package.json), agent personality definition (character file), and Nosana deployment specifications. The template emphasizes privacy and decentralization, allowing users to run their agent on infrastructure they control via Nosana's distributed GPU network. The agent leverages Nosana-hosted LLM (Qwen3.5-27B) and embedding models for inference, with environment variables configured to point to Nosana's endpoints. Users can customize the agent by modifying the character file, adding ElizaOS plugins for extended functionality (e.g., web search, social media), and implementing custom logic in the provided TypeScript entry point (src/index.ts). The template follows ElizaOS best practices and includes clear documentation for local development and deployment to Nosana. While the repository serves as a solid starting point, it requires user customization to become a functional agent. The codebase is well-maintained with recent commits, uses current dependencies, and demonstrates proper project structure for an ElizaOS application. It successfully fulfills its purpose as a challenge template for creating personalized AI agents on decentralized infrastructure.

SpatialClaw is a research framework for spatial reasoning agents — LLM/VLM agents that answer spatial questions about images and video by writing and executing Python code. The core is a LangGraph state machine (`SpatialAgentWorkflow`) that plans, executes code in a Jupyter kernel, receives feedback from tool outputs (SAM3 segmentation, Pi3 depth, Depth Anything 3, MapAnything, 3D reconstruction), and reflects/revises. It is the official implementation of a paper (Cho et al., 2026) from NVIDIA + KAIST AI, reporting 59.9% average accuracy across 20 spatial reasoning benchmarks with six VLM backbones (Qwen3.5/3.6, Gemma4, 26B–397B).

XianyuAutoAgent is an AI-powered customer service bot for the Chinese second-hand marketplace platform Xianyu (闲鱼). It connects via WebSocket to Xianyu's messaging service, receives user messages, and generates intelligent replies using a Large Language Model (LLM) with multi-expert routing. The system features intent classification (price negotiation, technical support, general query), dynamic pricing negotiation with gradual concessions and adaptive LLM temperature, context-aware conversation management via SQLite, and a manual takeover mode. It handles authentication via cookies, token refresh, heartbeat, and captcha-triggered cookie re-entry. The bot operates as a long-running async process, suitable for deployment via Docker.

Paper2Code is a research system that automatically generates runnable code repositories from machine learning research papers. The core pipeline, PaperCoder, uses a multi-agent LLM architecture (planning→analysis→coding) implemented as a sequence of Python scripts orchestrated via shell commands. It accepts papers in PDF (converted to JSON via s2orc-doc2json), JSON, or LaTeX format, and produces a complete Python project with config, model definitions, training loops, and evaluation scripts. The codebase supports both OpenAI API (o3-mini by default) and open-source models via vLLM (e.g., DeepSeek-Coder-V2-Lite-Instruct). It includes a debug stage that iteratively fixes runtime errors using LLM-generated SEARCH/REPLACE patches, and an evaluation module that scores generated repositories (reference-free or reference-based) using LLM judgment. The repository also bundles the Paper2Code benchmark dataset (90 papers from top ML conferences with gold repositories) and prompts for evaluation. Although primarily an application, it has research artifacts (evaluation scripts, prompt templates, benchmark data) that give it a hybrid character.

DeepReviewer-v2 is a backend-only application designed for automated academic paper review. It processes PDF papers through a pipeline involving MinerU for markdown conversion, an LLM-based review agent with tool usage (e.g., paper search, annotation), and PDF report generation with annotated source overlays. The system operates asynchronously with job persistence, featuring a CLI for job submission, status tracking, and result retrieval. Optional integration with PASA (via vLLM) enables external paper search. The architecture is modular, separating concerns into adapters, tools, state management, and report generation components, all coordinated via an async runner.

This repository serves as a landing page for the Letta project, directing users to the current implementation in the `letta-ai/letta-code` repository. It contains policy files (contributing, privacy, security, terms), an AI usage policy, citation metadata, and GitHub workflows to enforce contribution guidelines. The main branch holds static markdown files, while the retired Letta V1 server code is preserved in the `archive` branch. The repository does not contain runnable application code but serves as an informational hub.

kimi-cli is MoonshotAI's Python AI coding assistant CLI, now explicitly archived and replaced by the TypeScript Kimi Code CLI. The pyproject.toml declares Development Status :: 7 - Inactive, the README states no further releases or security fixes will ship, and the final release (1.52.0) is a deprecation shim: every entry point short-circuits to a notice that downloads and installs the successor via a CDN script. Tests in the repo actively enforce that the legacy Typer CLI is unreachable. In its working life it was a full-featured terminal agent with interactive shell (prompt_toolkit/Rich), print mode, file editing tools, shell execution, web fetch/search, subagents, plan mode, approval workflows, background tasks, hooks, plugins, MCP server management, OAuth, and session persistence.

The MetaOpenFOAM repository is an application that automates the setup and execution of OpenFOAM CFD simulations using a multi-agent system powered by Large Language Models (LLMs). It integrates the MetaGPT framework to define specialized agents (Architect, TaskDivide, InputWriter, Runner, Reviewer) that collaboratively interpret user requirements, generate OpenFOAM input files, run simulations, and review results. Additionally, it incorporates the active_subspaces library for parameter optimization and sensitivity analysis in the `OptMetaOpenfoam.py` workflow. The system processes OpenFOAM tutorials to build retrieval-augmented generation (RAG) vector databases, enabling the LLM agents to access relevant case information when generating simulation inputs. Configuration and path management are handled via a centralized YAML configuration, and the application relies on external dependencies including OpenFOAM-10, Conda, and LLM APIs (OpenAI or DeepSeek). While the project demonstrates a sophisticated integration of CFD simulation, LLM agents, and sensitivity analysis, it is marked as deprecated in favor of a successor tool (sim-cli).