mark3labs/mcp-go is a production-oriented Go SDK implementing both server and client sides of the Model Context Protocol (MCP). The codebase is a library, not a standalone application: it exposes server.NewMCPServer, client.NewClient, and transport constructors for stdio, SSE, Streamable HTTP, and in-process communication. It supports tools, resources, prompts, tasks, sampling, elicitation, roots, completions, subscriptions, multi-round-trip requests, OAuth, OpenTelemetry tracing, schema validation, and cursor-based pagination. The SDK maintains dual-era protocol support, negotiating between legacy handshake-based versions (2024-11-05 through 2025-11-25) and the modern stateless 2026-07-28 core, with automatic per-request era detection and bridging for server-initiated requests. Architecturally, the repository is organized as modular Go packages: mcp defines protocol types and schema helpers, server implements JSON-RPC dispatch, sessions, middleware, hooks, tasks, and HTTP/SSE/stdio transports, while client provides a high-level client plus a transport abstractions layer. Notable engineering strengths include defensively coded transports, resumable SSE streams with event replay, an OAuth layer hardened against RFC 9728 resource-binding attacks, cached JSON Schema validation, and an extensive test suite including conformance tests, race-condition tests, and e2e HTTP tests. The repository also ships a separate otel submodule for OpenTelemetry integration and a docs site under www/. This is purely an application/infrastructure repository; there are no data pipelines, notebooks, or research artifacts. The primary data flow is JSON-RPC messages exchanged between MCP servers and clients, with SSE used for notifications, streaming, and server-to-client requests. The code is strongly standards-driven and tightly tracked to the evolving MCP specification. While the dual-era protocol support adds significant complexity and maintenance burden, the implementation is well-tested, security-conscious, and contains several genuinely reusable components. A few stale example files and commented-out tests exist, but they do not materially affect the quality of the core SDK.
Javalin is a lightweight web framework for Java and Kotlin, built on top of the Jetty HTTP server. It provides a fluent, consumer-based configuration API for defining HTTP routes, WebSocket endpoints, Server-Sent Events (SSE), static file serving, and more. The framework emphasizes simplicity and developer experience by avoiding annotations and reflection, instead using lambda handlers and a plugin system for extensibility. Core features include request/response handling with before/after lifecycle hooks, path parameter parsing, validation, JSON serialization (Jackson 2/3, Gson), compression (gzip, brotli, zstd), CORS, rate limiting, and SSL/TLS support. The architecture is modular, with separate packages for routing, configuration, plugins, and utilities, and optional satellite modules for metrics (Micrometer), template rendering (multiple engines), and testing tools. Javalin is designed as a library to be embedded in applications, not as a standalone server, and is distributed via Maven Central.
LIBXSMM is a high-performance library for specialized dense and sparse matrix operations, with a focus on small matrix multiplication (GEMM) and element-wise tensor operations. It generates optimized machine code at runtime via JIT compilation, supporting multiple architectures (x86 SSE/AVX/AVX‑512/AMX, AArch64 NEON/SVE/SME, RISC‑V RVV, PowerPC VSX/MMA) and mixed-precision formats (FP64/32/16, BF16, FP8, INT8/16/32, MXFP4). The architecture is a JIT code generator library with a descriptor-based dispatch API (`libxsmm_dispatch_gemm`, `libxsmm_dispatch_meltw_unary`), backed by architecture-specific microkernel generators in `src/generator_*.c`. Key entry points include the public header `include/libxsmm.h`, the CPU feature detection (`libxsmm_cpuid_*.c`), and the binary export tool for offline kernel generation. Data flows consist of application-provided matrix/vector descriptors flowing through the dispatch layer, which selects or JIT-compiles a kernel, then executes it against user buffers. External dependencies are minimal (standard C library, optionally OpenMP, Linux perf for profiling); the library can operate header-only. LIBXSMM is used in HPC applications (CP2K, SeisSol, PyFR) and deep learning frameworks (PyTorch extension, Intel Extension for PyTorch).
Composio is a production-grade, dual-language SDK monorepo that connects AI agents to external services (Gmail, GitHub, Slack, Notion, Salesforce, and hundreds more) through a unified tool abstraction. In production it operates as the client layer of the Composio platform: applications create a Composio session bound to a user_id, discover toolkits, manage OAuth auth-configs and connected accounts, and execute tool calls either remotely or via a session-scoped Tool Router that also exposes hosted MCP endpoints. The repository ships a TypeScript SDK (@composio/core), a Python SDK (composio), a standalone Effect-TS-based CLI, 15+ framework provider adapters (OpenAI, Anthropic, LangChain, LlamaIndex, CrewAI, AutoGen, Mastra, Vercel AI, Google/ADK, etc.), and a Next.js documentation site. It is unambiguously an application/developer-platform repo rather than data research, although it contains data-adjacent engineering assets: a cross-SDK JSON Schema conversion corpus, OpenAPI dereferencing tooling, a knowledge-base hybrid-search index, and telemetry redaction utilities.
Mastodon.py is a mature Python client library for the Mastodon social network API. It provides a comprehensive, type-safe interface to all Mastodon endpoints (statuses, accounts, timelines, notifications, admin, streaming, etc.) with built-in pagination, rate limiting, OAuth authentication, and version compatibility detection. The library is split across multiple modules that compose a single `Mastodon` class via inheritance, offering both synchronous and streaming access. It is extensively tested against a local Mastodon instance using VCR-recorded cassettes and supports optional features like WebPush notifications, blurhash decoding, and grapheme-based status length calculation. The codebase is well-maintained with modern Python packaging (pyproject.toml), type annotations, and support for Python 3.6 through 3.14.
Dynacat is a self-hosted, configurable personal dashboard application forked from Glance. It aggregates content from dozens of external services — RSS/Atom feeds, Reddit, Hacker News, Twitch, YouTube, weather (Open-Meteo), financial markets (Yahoo Finance), Docker containers, media servers (Plex/Jellyfin/Emby/Navidrome), torrent clients, and DNS servers — into a single YAML-configured page layout. The backend is a Go HTTP server built on the standard library, serving server-rendered HTML templates with progressive enhancement via vanilla JavaScript, htmx, and SSE for live widget updates. It supports password-based and OIDC authentication, per-page access control, a CSS-variable theme system, and PWA/installability features. Architecturally, the codebase centers on a widget plugin system: each widget type implements a common lifecycle (initialize, update, render, optional request handling) registered in a factory. Shared infrastructure includes a disk-based image cache with proxy fallback, a singleflight-based shared HTTP request layer that deduplicates concurrent external fetches, a generic worker pool for parallel requests, and an SSE update loop. Configuration supports YAML includes, environment variable and Docker secret substitution, and hot-reload via fsnotify. The code is well-organized for a fork of this size: shared patterns are extracted into reusable helpers (generic singleflight, worker pool, custom YAML unmarshalers, and a standalone sysinfo package under pkg/), and focused unit tests cover auth and several widgets. Main caveats are large monolithic widget files (700–900 lines mixing HTTP, parsing, and rendering), duplicated fetch logic across the 'latest-media' and 'playing' widgets, and heavy reliance on many external APIs whose availability or rate limits can affect the dashboard. The project is actively maintained with frequent releases, GitHub Actions CI/CD, and a goreleaser setup for multi-arch Docker images.
Air is a command-line live-reload utility for Go application development. It watches a project directory for file changes, automatically rebuilds the project using a configurable build command, and restarts the resulting binary. The tool includes an embedded HTTP reverse proxy that injects a JavaScript snippet into HTML responses, enabling automatic browser reload via Server-Sent Events after each successful rebuild. It supports custom build commands, pre/post hooks, environment file loading, platform-specific build overrides, and watch rules that run commands instead of triggering a full rebuild (e.g., for frontend asset pipelines or code generation). The architecture is a single Go binary with a main event loop that uses filesystem notifications (or polling) to detect changes, spawns build processes, and manages child process lifecycle. The codebase is well-structured with clear separation of concerns: configuration parsing (runner/config.go), engine orchestration (runner/engine.go), file watching (runner/watcher.go), HTTP proxy (runner/proxy.go), and platform-specific process management (runner/util_*.go). It includes a comprehensive test suite and CI pipelines for Linux, macOS, and Windows. The proxy component, in particular, demonstrates sophisticated handling of content encoding (gzip, brotli), streaming responses (SSE, chunked transfer), and hop-by-hop header management, making it a reusable pattern for adding live-reload capabilities to any Go web application.
f1-dash is a real-time Formula 1 telemetry and timing dashboard. It consists of a Rust backend that connects to the official F1 live timing SignalR endpoint, ingests data (timing, car metrics, positions, weather, race control messages, team radios), and streams it via Server-Sent Events (SSE) to a Next.js frontend. The frontend displays a leaderboard, track map with driver positions, weather complications, race control messages, team radios, and a schedule page. It supports a delay feature to sync with TV broadcasts. The architecture is multi-service: a realtime service handles the SignalR connection and SSE, an API service provides schedule data from an iCal feed, and the dashboard is a standalone Next.js app. The codebase is well-organized with reusable Rust libraries (SignalR client, state service) and frontend utilities (deep merge, inflate, buffer for delayed playback, map rendering). It demonstrates strong engineering practices, though the project is currently in maintenance mode with the author focusing on other projects.
zlFetch is a lightweight JavaScript library that wraps the native Fetch API with quality-of-life improvements. It automatically parses response bodies based on `Content-Type` (JSON, text, form-urlencoded, NDJSON, Blob), provides promise-based error handling that rejects on 4xx/5xx status codes, supports request aborting, and includes shorthand methods for GET, POST, PUT, PATCH, DELETE. The library also offers streaming capabilities (SSE, NDJSON, chunked transfer), an EventSource wrapper for server-sent events, query string helpers, authorization header helpers, and a `createZlFetch` factory for pre-configured instances. The code is modular, well-typed with JSDoc, and thoroughly tested across browser and Node.js environments using vitest.
Datastar is a lightweight, reactive frontend library that enables building dynamic web applications using declarative HTML attributes and server-sent events (SSE). Its core architecture is a plugin-based engine that registers attribute plugins, action plugins, and watcher plugins. The system includes a fine-grained reactive signal system (signals, computed, effects) with batched updates and deep proxy support, a DOM morphing algorithm for efficient patching, and an SSE client with retry logic. The library also provides built-in plugins for event handling, two-way binding, conditional rendering, form support, and more. The repository includes a comprehensive SDK test suite (in Go) for validating backend implementations, as well as IDE plugins for VS Code and IntelliJ. Although the official SDKs for multiple languages have moved to separate repositories, the test suite and architecture documentation remain here. The codebase is well-structured with clear separation of concerns, but contains some unresolved merge conflicts and no visible test coverage for the core library, indicating moderate technical drift.
Fuel is a Kotlin Multiplatform HTTP networking library built on kotlinx.coroutines, providing suspend-style HTTP verbs (GET, POST, PUT, PATCH, DELETE, HEAD, arbitrary methods) plus Server-Sent Events streaming across JVM, Apple (iOS/macOS), and WasmJS targets. The core fuel module uses an expect/actual split: a common HttpLoader interface and FuelBuilder are backed by OkHttp on JVM, NSURLSession on Apple, and the browser fetch API on WasmJS. A global Fuel object supports plugging in a custom loader or loader factory, and extension functions on String (httpGet(), httpPost(), etc.) provide concise request entry points. A FuelRouting interface lets applications model typed API endpoints as sealed classes. Four optional serialization modules — fuel-jackson-jvm, fuel-moshi-jvm, fuel-kotlinx-serialization, and fuel-forge-jvm — each add a small extension on HttpResponse (toJackson, toMoshi, toJson, toForge) that decodes the body and returns a Result from the companion Result library. The core response model is deliberately minimal: a mutable HttpResponse holding a status code, a kotlinx.io Source body stream, and headers. JVM request handling is semantically correct about HTTP (e.g., consulting OkHttp's HttpMethod.permitsRequestBody before attaching a body). The project is published as 3.0.0-alpha04, uses Kotlin 2.3 / Gradle 9.3 / OkHttp 5 alpha, and is actively maintained with CI, Renovate, Dependabot, and ktlint. JVM has solid unit coverage using MockWebServer for all verbs, routing, custom OkHttp configurations, and each serialization adapter. Apple and Wasm targets are implemented but largely untested outside manual samples, and the Apple SSE implementation is a naive full-body line splitter rather than true incremental streaming. Overall this is a clean, modern, well-organized library with a couple of genuinely reusable pieces (notably the Android-derived UriCodec port) and some pre-1.0 rough edges. This is a pure application/library repository, not a data project.
WaterCrawl is a full-stack web crawling and data extraction platform, built as a SaaS-style multi-tenant application. The backend is implemented in Django 5.1 with Django REST Framework, providing REST APIs for crawl requests (single/batch URL), web search (Google Custom Search integration), sitemap generation, and proxy server management. Asynchronous task execution is handled by Celery workers that invoke Scrapy spiders (SiteScrapper, GoogleCustomSearchScrapper, SitemapScrapper) and optionally use Playwright for JavaScript rendering. Real-time status updates are pushed to the frontend via Redis Pub/Sub and Server-Sent Events (SSE). The frontend is a React SPA (with TypeScript, Tailwind CSS, react-hook-form) that provides dashboard pages for configuring and monitoring crawl/search/sitemap jobs, managing teams and API keys, viewing usage statistics, and handling subscription billing through Stripe. Authentication supports JWT (simplejwt) and OAuth (Google, GitHub), with email verification and team invitation flows. The application stores extracted content (markdown, HTML, attachments) in MinIO or S3-compatible storage, and metadata in PostgreSQL.
Iodine is a high-performance concurrent web server for Ruby applications, built as a wrapper around the C-based facil.io framework. It provides native HTTP/WebSocket/Server-Sent Events support, Rack compliance for serving Ruby web applications, and a built-in Pub/Sub system with optional Redis scaling for horizontal distribution. The architecture follows a master-worker model using multiple processes and threads to handle thousands of concurrent connections, with critical networking components implemented in C for performance and Ruby bindings for developer productivity. Key features include static file serving with gzip and X-Sendfile support, a secure Mustache template engine with automatic HTML escaping, a fast JSON parser claiming 20-90% speed improvements over Ruby's standard library, and TLS support (though marked as having known issues for production use). The server integrates with Rack applications through a custom handler and provides upgrade hooks for WebSocket/SSE protocols via the Rack environment. Pub/Sub functionality uses an engine pattern allowing swap between internal cluster-based and external Redis backends. Entry points include the `exe/iodine` CLI executable and programmatic controls via `Iodine.listen`, `Iodine.start`, and `Iodine.stop`. Data flows involve HTTP requests parsed by the C-based HTTP processor, routed to Rack applications or static file handlers, with WebSocket connections upgraded via Rack's `env['rack.upgrade?']` mechanism. The Pub/Sub system operates independently for real-time messaging across processes or machines. External dependencies include the vendored facil.io C library, OpenSSL development headers for TLS support, and optionally the Redis gem for clustered Pub/Sub.
MCPM (Model Context Protocol Manager) is a production-grade CLI tool for managing Model Context Protocol (MCP) servers. It provides a centralized server registry, global configuration, virtual profile system (tags), multi-client integration (Claude Desktop, Cursor, Windsurf, VSCode, Cline, Goose, and 10+ more), direct server execution via stdio/HTTP/SSE, secure public sharing via tunnels, and usage monitoring/analytics. The tool is designed for both interactive use and AI-agent automation (non-interactive mode with environment variables). The repository also contains a curated registry of 400+ MCP server definitions (JSON manifests) with metadata and installation instructions. While primarily a Python CLI application, the registry component adds a hybrid data/configuration dimension. The architecture follows a monolith command pattern with modular command implementations, client adapters using base class inheritance, and optional FastMCP proxy for server aggregation.
Dromara/forest is a declarative HTTP client framework for Java. It allows developers to define HTTP APIs via annotations on interfaces, similar to Retrofit for Android, but targeting the Java ecosystem with deep integration for Spring Boot and Solon. The core engine uses dynamic proxies to intercept interface invocations, builds HTTP requests from annotation metadata, and dispatches them to pluggable backends (Apache HttpClient, OkHttp3). It supports all HTTP methods, file upload/download, JSON/XML/Protobuf serialization, server-sent events (SSE), OAuth2 authentication, retry/redirect policies, cookie management, and async execution (including Kotlin coroutines and Project Reactor). The architecture is modular: a core library defines the annotation lifecycle, request/response models, converter abstractions, and interceptor chains, while separate modules provide Spring Boot auto-configuration, Solon plugin, JAXB/Jakarta XML converters, and a mock server for testing. The framework is designed for production use with customizable logging, SSL, proxy, and connection pooling. External dependencies include OkHttp3, Apache HttpClient, Jackson/Gson/Fastjson for JSON, and optional Reactor/Kotlin. The project includes extensive examples for integrating with AI APIs (ChatGPT, DeepSeek) and standard REST services.
This repository provides a header-only library, NEON_2_SSE.h, that enables porting of ARM NEON intrinsics code to x86 platforms by mapping ARM NEON intrinsics to equivalent x86 SIMD intrinsics (SSE, AVX2, etc.). The library is designed to be used as a drop-in replacement for arm_neon.h when compiling for x86, allowing developers to write SIMD code using NEON intrinsics that can be compiled on both ARM and x86 without modification. The project includes a CMake-based build system for installation and packaging, and the header is self-contained, requiring only the target platform's compiler intrinsics headers. The codebase appears to be stale, with the latest copyright dates in the provided files (LICENSE, CMakeLists.txt) indicating updates up to 2020. The provided last commit date (2026-04-28) is invalid (future date), suggesting a data error, but the file copyrights imply no recent activity. The library focuses on compatibility up to AVX2 and does not show signs of technical drift, as it relies on stable compiler intrinsics interfaces. The primary value lies in the NEON_2_SSE.h header, which implements a non-trivial mapping between SIMD architectures.
jsconsole is a web-based JavaScript REPL and remote debugging tool. The frontend is a React (Preact-compat) single-page application with Redux state management, allowing users to type and execute JavaScript commands in a sandboxed iframe. Results are rendered with a rich type-aware display that supports expand/collapse for objects, arrays, functions, promises, and more. The backend is a Node.js/Express server that serves the static build and provides real-time communication via Server-Sent Events (SSE) for remote debugging sessions. Users can start a remote session (listen) to bridge console.log calls from another browser or device back to the main console, and also inject commands remotely. Architecturally, the codebase follows a standard client-server model with a React SPA. It makes clever use of AST parsing (via Babylon) in the `preProcess` function to handle JavaScript declarations (const/let) and async/await in the REPL, transforming input so that eval returns the final expression value. The backend uses a lightweight custom SSE session manager (`lib/es.js`) that could be extracted for other real-time projects. However, the project is technically very dated, with React 15, Webpack 2, and many other dependencies from 2017-2018. Despite this, the core REPL logic and type-rendering components are well-architected and could serve as a reference implementation for similar tools.