Reactive Resume is a full-stack, open-source resume builder and job application tracker. It provides a rich web interface for creating, editing, and managing resumes with real-time preview, multi-format export (PDF, DOCX, Markdown, JSON), and ATS compatibility analysis. The system includes an AI-powered assistant for resume tailoring and cover letter drafting, an MCP server for LLM integration, and a semantic CSS stylesheet system for fine-grained PDF styling. The architecture is a monorepo with a React frontend (TanStack Router, Zustand, Lingui i18n), a Node.js API layer (oRPC, Drizzle ORM, PostgreSQL), and dedicated packages for PDF generation, DOCX export, authentication, and UI components. Key entry points include the resume builder interface, public resume sharing pages, an AI agent chat, and a job application board with stage tracking and CSV import/export. External dependencies include PostgreSQL, Redis, AI provider APIs (OpenAI, Anthropic, Gemini), and cloud storage (Vercel Blob or S3). The codebase is well-structured with extensive unit and integration tests, a reusable UI component library, and a modular package architecture that supports self-hosting via Docker or Vercel.
Tailscale is a production-grade mesh VPN application that creates secure WireGuard-based networks between devices. The repository implements a complete VPN solution: a daemon (`tailscaled`) that manages networking, a CLI (`tailscale`) for user interaction, a DERP relay server for NAT traversal, a Kubernetes operator, a WebDAV-based file sharing system (Taildrive), an SSH server, a DNS resolver, and a web-based management UI. The architecture is modular with feature flags via build tags, extensive platform support (Linux, Windows, macOS, iOS, Android, FreeBSD, etc.), and a plugin-style hook system for optional components (port mapping, app connectors, TPM attestation, etc.). Key data flows include control plane communication via Noise protocol, peer-to-peer connections with NAT traversal (STUN, PCP, UPnP), DNS configuration through OS-specific managers, and file transfers via Taildrop. External dependencies include WireGuard, gVisor netstack, Kubernetes client-go, and AWS SDK. The codebase demonstrates strong engineering practices: extensive tests (unit, integration, VM-based), immutable view types, code generation for cloning and serialization, and careful concurrency with custom utilities like sharded maps and event buses.
FastMCP is a production-oriented Python framework for the Model Context Protocol (MCP). Rather than being a single application, it is a multi-package library stack: `fastmcp_slim` provides the core server/client framework, `fastmcp_remote` bridges remote MCP servers to local stdio, and `fastmcp_tasks` implements SEP-2663 background task execution. The core architecture centers on the `FastMCP` server class, a `Client` class with transport abstraction (stdio, SSE, Streamable HTTP, in-memory), provider-based component registration (local, filesystem, OpenAPI, proxy, skills), composable middleware, transforms, OAuth/OIDC authentication, OpenTelemetry instrumentation, and a CLI for running, installing, deploying, and inspecting servers. Entry points include the `fastmcp` CLI and the Python APIs `FastMCP`, `Client`, `ClientGroup`, `FastMCPApp`, and `TasksExtension`. This is an application framework, not a data/research repository, though it contains information-retrieval components (BM25 and regex tool search), OpenAPI schema conversion machinery, and telemetry utilities that approach data-engineering utility. The codebase demonstrates strong engineering discipline: extensive unit and integration tests, conformance testing against the MCP spec, lazy imports to preserve startup performance, upgrade-guide tests that verify documentation claims, and a transform/middleware system that keeps extensions decoupled from core server logic. External dependencies include the MCP Python SDK, Pydantic, Starlette/ASGI, OpenTelemetry, optional authlib, optional prefab-ui for interactive apps, and an internal `httpx2` fork, which is the most notable maintenance risk in an otherwise current codebase.
This is the official Python SDK for the Model Context Protocol (MCP), a protocol for integrating AI models with external tools, resources, and prompts. The SDK provides both a high-level decorator-based API (MCPServer) and a low-level handler-based API (Server) for building MCP servers, along with a full client implementation (Client) for connecting to servers. It supports multiple transports (stdio, SSE, streamable HTTP), OAuth 2.0 authentication, caching, subscriptions, progress reporting, structured output, and an extension system. The codebase is well-structured with clean separation of concerns, extensive test coverage (unit, integration, documentation-sourced), and reusable patterns for authentication, caching, path security, and URI template parsing. It is actively maintained with recent commits and a comprehensive CI pipeline.
Better Auth is a framework-agnostic authentication and authorization framework for TypeScript, designed as a monorepo with a core library, multiple database adapters (Drizzle, Prisma, Kysely, MongoDB, in-memory), client SDKs (React, Vue, Svelte, Solid, Expo, Electron), and a plugin ecosystem. It supports email/password, OAuth2/OIDC, SAML, SCIM, passkeys, 2FA, phone number OTP, and more. The architecture is modular: the core package provides the `betterAuth()` function, which configures plugins, database adapters, and social providers, and exposes a REST API for authentication flows. Client libraries use nanostores for reactive state management. The CLI offers project scaffolding, migration generation, and schema validation. External dependencies include jose for JWT, zod for validation, and various ORMs for database access. The codebase is well-tested with unit, integration, and e2e tests across all packages, and includes a release tooling package with AI-assisted changelog generation.
Skybridge is a production-grade, full-stack TypeScript framework for building interactive MCP (Model Context Protocol) Apps and ChatGPT Apps. It provides a unified runtime to develop server-side tools with rich React-based UI views that render inside AI chat hosts like ChatGPT, Claude, Cursor, and VSCode. The framework is structured as a monorepo with packages for the core server/client library (`skybridge`), a Vite plugin for build orchestration, a developer tools SPA for local debugging, a project scaffolding CLI (`create-skybridge`), and an eval/test harness. The architecture centers on a typed MCP server implementation that handles tool registration, per-tool OAuth 2.1 authentication, an onion-model middleware system, and view resource serving. On the client side, a bridge abstraction (HostAdaptor) normalizes communication across different host protocols (OpenAI Apps SDK vs. MCP App JSON-RPC), while React hooks provide type-safe access to tool calls, view state, user context, and display modes. The framework emphasizes a 'reason, then render' two-phase pattern: a tool call computes data, then a view displays it interactively. Extensive examples cover e-commerce, games, authentication, productivity dashboards, and generative UI, demonstrating the framework's flexibility. Skybridge is not a data research project; it is a developer toolchain for building agent-native applications.
This repository implements a production-grade Model Context Protocol (MCP) server that exposes GitHub's REST and GraphQL APIs as a collection of tools, resources, and prompts for AI agents. The server runs in either stdio (local CLI) or HTTP (remote) mode, supporting multiple authentication methods: personal access tokens, OAuth 2.1 (PKCE browser flow, device flow, manual fallback), and GitHub App installation tokens. It provides over 90 fine-grained tools organized into toolsets (issues, pull requests, actions, projects, code scanning, etc.), each with metadata including required OAuth scopes, feature flags, read-only hints, and information flow control (IFC) labels. The architecture is modular: a central inventory builder registers all tools, resources, and prompts; per-request filtering narrows availability based on authentication, feature flags, toolsets, and read-only mode. The HTTP server uses a chi router with middleware for CORS, body limits, token extraction, scope challenge, and MCP method parsing. A React-based UI (Primer components) provides sandboxed forms for creating and editing issues and pull requests, served as embedded HTML resources. The server also includes lockdown mode for prompt injection mitigation, sanitization of user-authored content, field filtering to reduce response size, and telemetry for metrics collection. External dependencies include the MCP Go SDK, go-github (REST), shurcooL/githubv4 (GraphQL), and various utility libraries for OAuth, HTML sanitization, and configuration.
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.
The Dropbox SDK for Python is an official library providing programmatic access to the Dropbox API v2. It enables developers to perform file operations, manage sharing, handle team administration, and interact with Paper documents through a Python interface. The SDK employs a code generation approach using Stone IDL to maintain API specification consistency, with hand-written components handling cross-cutting concerns like authentication, session management, and request resilience. Architecturally, the library is structured as a importable package with clear separation between transport logic (session management), core request handling (including OAuth 2.0 token refresh and exponential backoff retry), and API-specific modules generated from specifications. Key features include automatic token refresh, connection pooling via shared sessions, Dropbox-specific content hash calculation for upload integrity, and comprehensive error handling. The SDK supports both user and team authentication scopes with proper scoping enforcement. The project demonstrates strong maintenance practices with automated CI/CD pipelines for testing, linting, and publishing to PyPI. A dedicated workflow keeps the SDK synchronized with Dropbox's API specifications through scheduled updates. While the majority of API interface code is generated, the manually maintained components exhibit robust engineering patterns suitable for reuse in other HTTP client implementations. The SDK targets developers building applications that integrate with Dropbox services, focusing on reliability, security, and ease of use.
This is a React Native SDK (v13) that wraps Plaid's native LinkKit SDK (iOS) and sdk-core (Android) using Expo Modules. It provides a session-based API for integrating Plaid Link flows—standard account linking, identity verification, Layer (phone-based), headless (no UI), and embedded search—as well as FinanceKit sync for Apple Card data on iOS. The architecture is a TypeScript layer with native implementations in Swift and Kotlin. Key entry points are async session creator functions (`createPlaidLinkSession`, `createPlaidIdentityVerificationSession`, etc.) that return session objects with `open()`/`start()` methods, and a React Native component `PlaidEmbeddedSearchView`. The SDK does not handle link token generation; developers must obtain tokens from their own backend. It supports both Expo managed (development builds) and bare React Native workflows, with CI testing on Expo 52+ and React Native 0.76+. The codebase is well-structured with comprehensive TypeScript types, contract tests that validate native-to-JS payload keys, version sync tests, and migration diagnostics that provide helpful errors for removed v12 APIs.
mcporter is a portable Model Context Protocol (MCP) runtime, CLI, and code-generation toolkit. It connects to configured MCP servers—over stdio, HTTP/SSE, or Chrome DevTools relay—and exposes their tools via a rich command-line interface (subcommands: list, call, resource, auth, config, serve, daemon, generate-cli, emit-ts, record, replay) and a programmatic API (createRuntime, createServerProxy). The architecture is modular: a config layer merges JSON/JSONC files and imports from common editor configs (Cursor, Claude, VS Code); a runtime layer manages transport connections with OAuth support, record/replay, and error classification; a daemon process pools keep-alive servers for low-latency reuse; and a codegen subsystem produces standalone CLIs or typed TypeScript clients from server schemas. The codebase is heavily tested (~150 test files, coverage ≥89.6%), follows modern TypeScript patterns, and supports protocol versions from 2024-10-07 to 2026-07-28. It is not a data pipeline or research project—it is a production-grade developer tool for integrating MCP-powered agents and workflows.
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.
zrok is a production-grade, self-hostable secure resource sharing platform built on OpenZiti overlay networking. It enables users to share web services, files, TCP/UDP tunnels, and VPN connections through firewalls and NAT without requiring inbound connectivity. The system supports both public and private sharing modes, OAuth authentication (GitHub, Google, OIDC), and includes a full REST API (v2), a CLI tool (`zrok2`), a React web console, a background agent daemon with gRPC remote control, and SDKs in Go, Python, and Node.js. Architecturally, zrok follows a controller-agent pattern. The controller is a Go REST server that manages accounts, environments, shares, accesses, frontends, namespaces, organizations, and bandwidth limits. It uses SQLite3 or PostgreSQL for persistence with versioned migrations, and integrates with InfluxDB for usage metrics and RabbitMQ (AMQP) for dynamic proxy mapping updates. The agent runs as a background process on the user's machine, managing child processes for each share/access and exposing a gRPC API for remote management. Frontend proxies (public, dynamic, socks, Caddy) handle incoming traffic with OAuth, basic auth, and interstitial pages. Key entry points include the CLI commands under `cmd/zrok2/` (e.g., `share`, `access`, `enable`, `admin`), the controller REST handlers in `controller/`, the agent gRPC service in `agent/agentGrpc/`, and the SDK packages in `sdk/golang/sdk`, `sdk/python/src/zrok2`, and `sdk/nodejs/sdk`. The system also includes a canary testing framework for continuous health validation and a comprehensive metrics/limits engine for bandwidth enforcement. External dependencies include OpenZiti (overlay network), InfluxDB (metrics), RabbitMQ (messaging), Caddy (optional web server), and various OAuth providers. The project is actively maintained with frequent commits, automated CI/CD, and multi-platform release pipelines (Linux, macOS, Windows, Docker).
This monorepo provides a comprehensive TypeScript SDK for the AT Protocol (Bluesky), including client libraries, server frameworks, OAuth authentication, identity resolution, data serialization (CBOR, CAR, CID), and lexicon-driven code generation. The architecture is modular, with ~50 packages organized by domain (clients, servers, utilities, definitions, OAuth, identity, bluesky-specific features). Key entry points include the generic XRPC client (`@atcute/client`), the OAuth browser and node clients, the XRPC server framework with WebSocket support, and the lexicon CLI for generating TypeScript bindings from AT Protocol schema definitions. Data flows involve typed API calls over HTTP/WebSocket, with automatic validation, rate limiting, and caching. External dependencies include `valibot` for runtime validation, `@noble/curves` for cryptography, and platform-specific WebSocket/Fetch implementations.
The official Buildkite CLI (`bk`) is a production-grade Go command-line client for the Buildkite CI/CD platform. It interacts with Buildkite's REST and GraphQL APIs to manage pipelines, agents, builds, jobs, clusters, secrets, teams, and more. The architecture follows a command-pattern with Kong-based parsing, a centralized factory for dependency injection, and a rich set of I/O primitives (spinners, pagers, confirmation prompts) that produce structured output (JSON, YAML, text tables). It includes advanced authentication flows (OAuth device/PKCE), token refresh, keyring-backed credential storage, and self-update capabilities. The codebase demonstrates strong engineering discipline with extensive parallel tests, mock HTTP servers, and a composable error handling framework.
The Dropbox SDK for JavaScript (dropbox-sdk-js) is a lightweight, promise-based client library that provides a programmatic interface to the Dropbox v2 API. It supports both Node.js and browser environments, with full OAuth 2.0/PKCE authentication, file upload and download with resumable and parallel streaming, exponential backoff retries, progress reporting, and content hash validation. The library is auto-generated from Dropbox's API specification (Stone) and exposes hundreds of endpoint methods covering files, sharing, team management, users, and more. It is designed for production use with robust error handling, rate-limit awareness, and environment-aware binary types. The codebase demonstrates strong architectural separation of concerns: authentication logic is encapsulated in `DropboxAuth`, file transfer logic in dedicated uploader/downloader classes, and API request routing in generated route definitions. The SDK is well-tested with unit, integration, and TypeScript type tests, and includes comprehensive examples for both browser and Node.js usage patterns.
JSON::JWT is a Ruby library implementing the JSON Web Token (JWT) family of standards, including JWS (JSON Web Signature), JWE (JSON Web Encryption), and JWK (JSON Web Key). It provides comprehensive cryptographic operations for signing, verifying, encrypting, and decrypting tokens using various algorithms (HMAC, RSA, ECDSA, RSA-PSS, and symmetric encryption). The library also includes JWK Set management with remote fetching and caching capabilities. The architecture is modular: JSON::JWT serves as the main entry point, delegating to JSON::JWS for signing/verification and JSON::JWE for encryption/decryption. JSON::JWK handles key representation and conversion between OpenSSL keys and JWK format. The JWK Set Fetcher provides a configurable HTTP client with pluggable caching, suitable for OpenID Connect discovery. The code demonstrates strong security practices, including constant-time comparison for MAC verification, protection against padding oracle attacks in CBC mode, and proper validation of algorithm headers to prevent algorithm confusion attacks. The test suite covers interop with other JWT libraries (Nimbus JOSE, jsrsasign) and RFC examples, ensuring correctness. Key external dependencies include OpenSSL for cryptographic primitives, Faraday for HTTP, and ActiveSupport for hash extensions. The library is actively maintained with support for Ruby 3.2-4.0 and recent security fixes.
This is a monorepo for Auth.js (formerly NextAuth.js), a framework-agnostic authentication library for web applications. The core engine (`@auth/core`) handles OAuth/OIDC, email/passwordless, credentials, and WebAuthn/Passkey authentication flows. It provides a unified API for session management (JWT or database-backed), CSRF protection, and cookie handling. The library is designed to be integrated into multiple frameworks via separate packages: `@auth/nextjs`, `@auth/sveltekit`, `@auth/express`, `@auth/qwik`, and `@auth/solid-start`. Each framework package adapts the core `Auth` function to the framework's request/response model, offering server-side handlers, middleware, and client-side hooks. The repository also includes over 80 built-in OAuth/OIDC provider definitions (e.g., Google, GitHub, Discord, Auth0) and 20+ database adapters (e.g., Prisma, Drizzle, MongoDB, PostgreSQL, DynamoDB) that implement a standard `Adapter` interface for user persistence. The project is now part of Better Auth, and the README recommends new projects use Better Auth unless specific feature gaps exist. The monorepo contains development apps, example applications, and a comprehensive documentation site built with Nextra.
Hanko is a production-grade, self-hostable authentication and identity platform written primarily in Go. The backend exposes public, admin, and management HTTP APIs plus a CLI for migrations, user import/export, JWK/JWT management, and config schema generation. Authentication is implemented as a custom state-machine engine (flowpilot) driving login, registration, password/passkey/MFA/third-party OAuth/SAML flows, backed by JWT sessions, device trust, webhooks, audit logs, and rate limiting. The persistence layer uses gobuffalo/pop with a broad set of per-entity persister interfaces and roughly 65 Fizz migrations covering users, emails, credentials, sessions, tenants, organizations, roles, SAML providers, and webhooks. The frontend is split into a TypeScript SDK (`@teamhanko/hanko-frontend-sdk`) and Preact-based web components (`@teamhanko/hanko-elements`) that render flow states into embeddable `<hanko-auth>` and `<hanko-profile>` elements. The repository also contains a quickstart Go server, framework examples for React, Vue, Angular, Next.js, and Express, Playwright e2e tests, Docker Compose stacks, and Kubernetes manifests. Data flows through Echo routers into flowpilot actions/hooks, which validate inputs, persist state, issue sessions, and trigger webhook events; PostgreSQL, Redis, SMTP, and external OAuth/SAML providers are the primary external dependencies. Overall the codebase is well-structured and heavily tested, with sophisticated security handling around redirect validation, account linking, multi-tenant isolation, and webhook signing. The main friction points are the custom flowpilot framework's learning curve, a very large configuration surface, duplicated example code, and some stale example/e2e toolchains relative to the core Go and Node versions.
Dillinger is a cloud-enabled, online Markdown editor with live preview, export to Markdown, HTML, and PDF, and synchronization with cloud storage services including GitHub, Dropbox, Google Drive, OneDrive, and Bitbucket. Built with Next.js 14 (App Router), the application uses Monaco Editor for editing, Zustand for client-side state management with localStorage persistence, and markdown-it with a rich plugin chain for rendering. It features a modular architecture with API routes for OAuth flows and file operations per cloud provider, a versioned public REST API (v1) for rendering and export, and separate packages for a CLI tool and an MCP server for LLM integration. The codebase is well-organized with clear component separation (editor, preview, sidebar, modals, UI primitives), custom hooks per integration, and comprehensive unit and E2E test coverage. Auxiliary agent/skill files and design system CSVs exist in the repository but are development tools, not part of the application runtime.