aiproxy is a production-grade AI API gateway written in Go, acting as a unified proxy between client applications and over 40 AI provider APIs (OpenAI, Anthropic, Gemini, etc.). It converts protocol formats (OpenAI, Anthropic, Gemini), handles authentication, rate limiting, load balancing, request caching, and detailed usage billing. The system includes a React admin dashboard for managing channels, tokens, models, groups, logs, and consumption. It also supports the Model Context Protocol (MCP) for integrating AI tool servers, both hosted and proxied. The architecture is monolithic with a plugin system for extensibility, storing state in PostgreSQL and Redis. It demonstrates strong engineering practices including comprehensive test coverage, efficient caching (multi-layer with keyed locks), sliding window rate limiting, and a clean adaptor pattern for provider abstraction.
Caveman is a multi-agent AI coding skill/plugin that compresses LLM output tokens by ~65-75% using a 'caveman' terse communication style. It's not a library or service but a distributed configuration package that installs into 30+ AI coding agents (Claude Code, Codex, Gemini, Cursor, Windsurf, Cline, Copilot, opencode, OpenClaw, etc.) through their native plugin/extension/rule-file mechanisms. The core deliverable is a set of SKILL.md prompt files that instruct models to drop articles, filler, pleasantries, and hedging while preserving exact technical substance, code blocks, URLs, and paths. The architecture is a single Node.js installer (bin/install.js) that auto-detects installed agents and dispatches to per-provider installation paths. For Claude Code specifically, it adds SessionStart and UserPromptSubmit hooks plus a statusline badge. The repo includes several sub-skills: caveman-commit (terse conventional commits), caveman-review (one-line PR comments), caveman-compress (rewrites memory files like CLAUDE.md into caveman format to save input tokens), caveman-stats (reads session logs to report real token savings), and cavecrew (compressed subagent definitions for investigator/builder/reviewer patterns). There's also caveman-shrink, an MCP middleware proxy that compresses tool descriptions. The codebase demonstrates strong engineering practices: symlink-safe flag file writes with O_NOFOLLOW and ownership verification, atomic settings.json merges with JSONC tolerance, defensive hook validation before writes, idempotent install/uninstall cycles, and a three-arm eval harness (baseline/terse/skill) for honest token compression measurement. The Python compress tool has safety guards against exfiltrating sensitive files and verifies backup integrity before overwriting. Test coverage is substantial across installer e2e flows, hook symlink safety, opencode plugin lifecycle, and config resolution order.
ThinkWatch is a Rust workspace implementing an AI gateway platform that fronts multiple model providers and MCP (Model Context Protocol) servers. It exposes OpenAI-compatible chat/completion endpoints, streaming, MCP tool-call routing, content filtering, and provider failover. The backend is split into crates: `common` (shared lifecycle/limits/access), `auth` (PoW login, API keys), `gateway` (model routing), `mcp-gateway` (MCP server proxying), `server` (REST admin/audit/trace endpoints), and `test-support` (integration test client). A React/TypeScript frontend in `web/` provides an admin console, setup wizard, limits panels, and MCP server management. Data flows: requests enter the gateway, pass through `check_limits`, `check_budget`, `check_access`, then `run_post_invoke`; `trace_id` is propagated across gateway, MCP, audit, and app logs stored in ClickHouse; Postgres holds users, API keys, budgets, and MCP server configs; Redis/Lua scripts enforce rate limits.
The JetBrains MCP Proxy Server is a Node.js application that acts as a middleware between MCP-compatible clients (such as Claude Desktop or VS Code) and JetBrains IDEs equipped with the MCP Server plugin. It discovers the IDE's MCP endpoint by scanning a predefined port range (63342-63352) or using a specified IDE_PORT environment variable, caches the endpoint, and periodically verifies its availability. The proxy then exposes an MCP server over stdio, forwarding tool listing and tool invocation requests to the IDE's HTTP-based MCP endpoint. The implementation uses the Model Context Protocol SDK for stdio communication and node-fetch for HTTP requests, featuring error handling, logging, and endpoint caching with periodic refresh.