MCP servers, clients and tools

Kimi is a terminal-based AI agent that autonomously plans and executes software development tasks by reading, editing, and running code. It operates as an intelligent command-line agent that breaks down high-level goals into sequences of shell commands and code edits, carrying them out without manual step-by-step guidance. The agent can run in an interactive loop, switch to a shell mode for direct terminal command execution, and operate in non-interactive or one-shot modes suitable for scripting. The project distinguishes itself through multiple integration and execution modes. It can run as an Agent Communication Protocol (ACP) server, allowing any ACP-supporting editor or IDE to invoke it, and offers a dedicated VS Code extension for seamless code editing within the editor. The agent supports plan-based autonomous execution, where it breaks down goals into sub-steps and executes them by reading, editing, and running code. It also provides a browser-based OAuth authentication flow for accessing user accounts and available models, and can connect to external tools and services through the Model Context Protocol with configurable timeouts. The CLI supports extensive configuration and extensibility, including file-based settings loading from TOML or JSON files, agent personality selection, API provider configuration, model selection, and custom skills directories that the agent automatically discovers and loads at startup. It includes lifecycle hooks that run shell commands on agent events, background task management with configurable concurrency and timeouts, and session management features for saving, resuming, and exporting sessions. The agent also offers a web UI for remote interaction and trace visualization, and an AI-enhanced Zsh plugin that adds agent capabilities to the shell.

This project is an automated deployment tool designed to streamline the installation, configuration, and maintenance of network proxy software on Linux servers. It functions as a command-line utility that manages the lifecycle of network tunneling services, enabling users to establish and control private traffic routing through repeatable, automated workflows. The tool distinguishes itself through an interactive, menu-driven interface that abstracts complex configuration parameters into selectable options, making it accessible for operators regardless of their technical background. It performs environment-aware path resolution to detect host architecture and distribution specifics, ensuring that binary packages and directory structures are correctly aligned during deployment. Furthermore, it integrates proxy processes directly into the host operating system as managed background daemons, ensuring automatic restarts and consistent boot-time initialization. Beyond initial setup, the project provides comprehensive infrastructure management capabilities, including automated service updates and configuration changes. It utilizes template-driven generation to create service files, ensuring that network traffic routing and security settings are applied consistently across remote server environments.

kubectl-ai is a natural language cluster operator and AI command assistant that translates plain-text prompts into executable Kubernetes commands. It serves as an interface between large language models and the Kubernetes API to enable cluster management through conversational text. The project implements a Model Context Protocol server to expose cluster operations as standardized tools for external AI clients. It uses a provider-agnostic model interface to support both cloud-based and local AI backends. The system covers natural language infrastructure control and AI-assisted DevOps through dynamic command translation and a bridge to the standard command line interface. It extends operational capabilities via plugin-based tool execution and integration with external Model Context Protocol servers.

Netty is an asynchronous network framework designed for building scalable protocol servers and clients. It utilizes an event-driven reactor pattern and a non-blocking input/output model to decouple connection handling from application logic, allowing for the development of responsive network services that manage high volumes of concurrent connections. The framework distinguishes itself through a modular pipeline-based processing chain that enables the implementation of custom binary or text-based protocols. It provides a pluggable transport abstraction that allows developers to switch between standard Java sockets and native platform-specific drivers without modifying application code. To maintain performance under high load, it employs zero-copy buffer management and reference-counted memory pooling, which minimize garbage collection pressure and facilitate low-latency data transmission. Beyond its core transport capabilities, the framework includes tools for secure network communication and the transformation of raw byte streams into high-level domain objects. It also provides mechanisms to reassemble fragmented data packets, ensuring that application logic processes complete units of information. Comprehensive documentation is available, including a user guide that details the construction of various network services and handlers.

Vibe-Trading is a system for automated financial trading and algorithmic market research. It uses autonomous agents to manage financial assets and execute trades based on predefined rules and logic. The project features a multi-agent collaborative workflow that coordinates specialized agents to perform joint research and risk reviews. It utilizes large language model orchestration to map natural language prompts to executable data loaders and backtesting functions. The platform includes capabilities for quantitative strategy backtesting and alpha benchmarking using information coefficients to determine signal decay. It provides tools for broker API integration to monitor accounts and positions in real time, as well as a data fallback chain to aggregate market information across multiple sources. Additional functionality includes financial trade analysis through the parsing of broker exports and trade journals to identify performance gaps between actual behavior and planned strategies.

This project is a terminal-based HTTP client designed for interacting with web services, debugging APIs, and automating network requests. It provides a specialized command-line interface that simplifies the construction of complex HTTP exchanges, allowing users to test and inspect web services directly from the shell. The tool distinguishes itself through a declarative syntax engine that translates shorthand command-line tokens into fully formed HTTP requests, including headers, parameters, and body payloads. It features a modular, plugin-based architecture that enables users to extend core functionality with custom authentication schemes, transport protocols, and data formatting logic. Furthermore, it supports persistent session management, allowing for the maintenance of cookies and authentication states across multiple related requests to simulate browser-like interactions. Beyond its core request capabilities, the tool provides a comprehensive suite of features for handling network traffic, including automated shell scripting with error handling, remote file downloading with progress tracking, and robust proxy support. It also offers advanced configuration options for HTTPS security, response streaming for large payloads, and terminal-aware output formatting that provides syntax-highlighted, human-readable displays.

Hatchet is an open-source durable workflow engine and task orchestration platform. It provides a framework for building and executing fault-tolerant, multi-step pipelines as directed acyclic graphs (DAGs), with automatic retries, scheduling, and real-time observability. The system is built around durable task checkpointing, which persists execution state after each step so work can resume from the last checkpoint after a worker crash or restart, and it supports event-driven task resumption that pauses a task until a matching external event arrives. The platform distinguishes itself through its support for polyglot workers connected over gRPC, allowing task code to be written in any language and scaled independently from the orchestration services. It offers a comprehensive set of capabilities for modeling workflows as DAGs with typed data passing between dependent tasks, parallel execution, and conditional task skipping or cancellation based on parent output. Hatchet also provides a multi-step human-in-the-loop orchestrator that pauses workflows for human input or external events and resumes from checkpoints without custom recovery logic, and it exposes durable tasks as callable tools for AI agents through the Model Context Protocol (MCP) or SDKs with retries and observability. The system includes a web-based observability dashboard for monitoring workflow runs, logs, metrics, and traces with real-time status and debugging capabilities. It supports event-driven task execution triggered by external webhooks, Slack commands, and custom events, as well as scheduled and cron-based automation for running one-off or recurring tasks. Hatchet can be self-hosted on your own infrastructure using Kubernetes or Docker, with PostgreSQL as the primary state store and optional RabbitMQ for message queuing.

SteamTools is a desktop utility designed to enhance the experience of using digital gaming platforms. It functions as a centralized management tool that provides account switching, network optimization, and feature extensions for various gaming storefronts. The application distinguishes itself through a modular plugin architecture that allows users to customize or disable specific functional components at runtime. It utilizes a local reverse proxy to intercept and redirect network traffic, which facilitates faster access to gaming services and enables the real-time injection of custom scripts into web-based gaming interfaces. Beyond these core capabilities, the tool supports comprehensive game library optimization by managing local configuration files and registry keys. This allows for the automation of launch settings and the efficient handling of multi-platform account profiles and shared library access.

This project is a comprehensive framework for building and managing autonomous agent systems. It provides a unified architecture for orchestrating multi-agent societies, where specialized agents collaborate through roleplay to decompose and solve complex tasks. The system integrates language models with external environments, enabling agents to perform real-world actions through a standardized tool-calling abstraction layer. The framework distinguishes itself through its focus on iterative reasoning and data reliability. It employs automated feedback loops to refine agent outputs and self-evaluate reasoning traces, ensuring high-quality results. To maintain operational integrity, the system enforces schema-based output parsing for reliable workflow integration and utilizes sandboxed environments for secure, isolated code execution. Beyond its core orchestration capabilities, the project includes a suite of utilities for retrieval-augmented generation and synthetic data production. It supports persistent memory management via vector-based context retrieval and provides extensive tooling for web automation, API integration, and human-in-the-loop oversight. The platform is designed to be model-agnostic, offering a consistent interface for interacting with a wide range of proprietary and open-source language models.

Shadowsocks-Windows is a desktop proxy manager that provides a graphical interface for configuring system-wide network routing. It functions as a local SOCKS5 or HTTP proxy server, intercepting outbound traffic through system-level injection to route requests through secure, encrypted remote tunnels. The application distinguishes itself through a modular architecture that supports plugin-based transport extensibility, allowing users to integrate external binaries for custom traffic obfuscation and specialized cryptographic protocols. It also enables high-availability networking by automatically rotating between multiple proxy servers based on real-time performance metrics, and supports multi-instance orchestration to manage independent proxy states and configurations simultaneously. Users can exercise granular control over network traffic through custom rule management, including the use of JavaScript-based auto-configuration files and geographic filtering to determine which requests bypass or traverse the proxy. The software further extends its utility by encapsulating connectionless datagrams into stream-oriented tunnels, ensuring that applications requiring UDP can function within the proxy environment.

Figma-Context-MCP is a design-to-code automation tool that functions as a server for the Model Context Protocol. It acts as a bridge between visual design platforms and development environments, enabling large language models to access design file metadata and component properties directly. The project distinguishes itself by providing a standard-compliant interface that translates design specifications into structured data. By extracting layout and styling information, it facilitates the programmatic conversion of design tokens and component requirements into actionable code structures. This tool supports automated frontend development by providing context-aware data to AI agents, ensuring that generated interfaces align with original visual intent. It covers the full design handoff process, from the retrieval of design metadata to the implementation of consistent design systems across a codebase.

This project provides a comprehensive implementation of the WebSocket protocol, enabling persistent, bidirectional communication between clients and servers. It handles the low-level complexities of the protocol, including the initial HTTP upgrade handshake and the encapsulation of data into discrete binary frames. By managing these connections, it allows applications to exchange data instantly without the overhead associated with repeated standard request cycles. The library distinguishes itself through its focus on high-frequency message exchange and concurrent connection management. It utilizes internal memory buffers to optimize network throughput and minimize system calls, while employing lightweight execution threads to maintain independent state for multiple active clients simultaneously. To ensure data integrity and compatibility, it also manages masking-based payload obfuscation for client-sent frames. Beyond core protocol support, the project includes a suite of web toolkit capabilities for building complete network applications. This includes mechanisms for routing HTTP requests, processing traffic through reusable middleware layers, and managing user sessions. It also supports remote procedure invocation, form data binding, and security features such as request forgery prevention and encrypted cookie handling.

This project is a framework for developing multimodal AI agents that function as programmable participants in real-time communication rooms. It enables the construction of agents that can see, hear, and speak by integrating speech-to-text, large language models, and text-to-speech pipelines to facilitate low-latency, natural conversations. The system is distinguished by its advanced orchestration of real-time media and conversational flow, including support for full-duplex speech, preemptive response generation, and sophisticated interruption management. It further differentiates itself through the ability to render photorealistic, synchronized digital avatars and integrate with SIP and PSTN networks for AI-driven telephony. The capability surface covers a broad range of agent logic, from dynamic tool execution and multi-agent session handoffs to structured data extraction and conversational state management. It provides comprehensive infrastructure for agent deployment, including managed hosting, distributed job dispatching, and real-time observability tools for monitoring session health and model performance. The project includes a Python SDK and command-line utilities for application scaffolding, local agent testing, and deployment management.

Composio is an integration platform designed to connect autonomous agents with external software services and APIs. It functions as a tool orchestration framework and a middleware hub, providing a unified interface for managing the lifecycle, authentication, and execution of external tool definitions within agentic workflows. The platform distinguishes itself by utilizing the Model Context Protocol to standardize communication between artificial intelligence models and external data sources. It employs a provider-agnostic adapter pattern to decouple core logic from specific model providers and uses remote procedure call orchestration to route agent-generated function calls to external services through a centralized gateway. The system supports automated workflow orchestration, enabling the creation of complex task sequences across third-party business applications. It features dynamic tool discovery and session state management to maintain isolated execution environments, ensuring that agents have access to current service capabilities and authentication tokens during runtime. The project provides a software development kit that standardizes session creation and tool retrieval to facilitate integration within native development environments.

This project is a curated library of community-driven prompt templates and personas designed to improve interactions with large language models. It functions as a prompt engineering guide, providing interactive tutorials and examples to teach advanced design and reasoning techniques. The library can operate as a Model Context Protocol server, providing a standardized interface for AI tools and agents to access prompt data as a service. For organizations, it offers a self-hosted repository option that allows for private deployment on internal infrastructure with custom authentication and data privacy. The system supports collaborative prompt management, enabling users to discover, share, and synchronize prompt templates within a shared dataset. It includes capabilities for content taxonomy and UI customization through a configurable theme system.

Shadowsocks is a secure network tunneling tool designed for censorship circumvention and private internet connectivity. It functions as a proxy system that routes traffic through encrypted tunnels, allowing users to bypass regional network restrictions and protect data from interception across public infrastructures. The project utilizes a lightweight, custom proxy protocol that incorporates stream-based cipher encryption to obfuscate payload content and prevent deep packet inspection. By employing an asynchronous, event-driven networking model, the system manages concurrent connections efficiently. It establishes secure communication through a structured client-server handshake and authentication process, ensuring that all data transmission adheres to defined encryption requirements. The framework provides a modular approach to building and deploying custom proxy infrastructure, featuring a cross-platform socket abstraction layer that ensures consistent traffic routing across different operating systems. This implementation allows for the configuration of specialized connection handlers to manage data flow between local clients and remote server endpoints.

This platform serves as a centralized management system for organizing, refining, and versioning AI instructions and agent skills. It functions as a repository that enables users to store, categorize, and retrieve structured prompts, ensuring consistent performance across various artificial intelligence models. By integrating with the Model Context Protocol, the system allows external AI assistants and development environments to discover and access these instruction libraries directly. The platform distinguishes itself through its focus on prompt engineering and automated refinement, utilizing generative analysis to transform basic user instructions into structured, high-performance prompts. It supports multi-tenant white-labeling, allowing for isolated, custom-branded deployments that include secure identity management and granular access control. Additionally, the system incorporates an interactive educational environment designed to teach users effective techniques for constructing and optimizing AI interactions. Beyond core management, the platform provides semantic search indexing to facilitate efficient discovery of relevant instructions based on user intent. It also supports the development of complex agent skills and includes automated workflows that enforce behavioral standards for AI interactions. The system is designed for both individual use and enterprise-grade infrastructure deployment, offering tools for visual customization and interface localization to meet diverse organizational requirements.

This project is a headless music streaming service proxy that provides a server-side interface for interacting with a specific music platform. It functions as a middleware layer, translating standard web requests into the proprietary communication protocols required by the remote service. By acting as a network traffic interceptor, the system enables programmatic access to music metadata, user playlists, and playback controls. The architecture operates as a middleman that intercepts client requests and relays them to the target service while managing necessary headers and parameters. It utilizes asynchronous network request handling to manage concurrent operations and maintains user authentication state through cookie-based session persistence. This design allows developers to build custom applications that integrate with the platform's data without requiring a graphical user interface. The system is built on a standard web framework that supports dynamic module loading, allowing for the addition of new endpoints through a structured directory. It provides a normalized API integration layer that formats external service data for consumption by third-party software. The application is configured via environment variables to support deployment across various hosting environments.

container-use is a containerized AI execution environment and code sandbox designed to provide a secure space for AI coding agents to execute commands and build applications. It functions as a workspace orchestrator that provisions isolated containers mapped to git branches, allowing multiple agents to operate in parallel without state conflicts or affecting the host system. The project serves as a Model Context Protocol server, bridging AI agents to containerized environments for standardized tool access. It enables a workflow for reviewing and merging changes made by agents within these isolated environments back into a local repository. The system includes capabilities for agentic workflow monitoring through command history logging and provides mechanisms for human intervention via direct terminal tunneling into active sessions. It further supports bidirectional file system syncing to facilitate the review and integration of agent-generated code.

Masscan is a command-line network scanner designed for large-scale discovery and infrastructure reconnaissance. It identifies open ports across specific network segments or the entire internet by probing vast address ranges with high efficiency. The tool functions as an asynchronous packet engine, bypassing standard operating system kernel networking stacks to transmit raw packets directly from application memory. The project distinguishes itself through a specialized architecture that manages millions of concurrent connections by separating packet transmission and reception into independent execution threads. It utilizes a stateless, index-based mathematical algorithm to randomize target selection, ensuring probes are distributed unpredictably across address spaces. To maintain consistent performance and prevent network congestion, the scanner employs a high-precision timer to regulate transmission rates and uses zero-copy buffer management to minimize memory overhead. The software provides a platform-agnostic interface for raw network access, allowing it to operate consistently across different hardware and operating system environments. It supports the export of collected reconnaissance data into structured formats such as XML, JSON, or plain text for further analysis. The application is distributed as a portable utility, with its core codebase maintained through standardized string handling and automated testing.