MarkItDown is a Python library and CLI tool that converts a wide variety of file formats (PDF, DOCX, PPTX, XLSX, HTML, CSV, JSON, EPUB, Outlook MSG, images, audio, YouTube, RSS, IPYNB, ZIP, and more) into Markdown. Its primary production use is preparing documents for LLM ingestion, agent workflows, and text analysis pipelines. The architecture is a monorepo containing the core `markitdown` package, an OCR extension (`markitdown-ocr`) that uses LLM Vision for image text extraction, an MCP server (`markitdown-mcp`) exposing conversion as a tool for AI agents, and a sample plugin for third-party converters. The core library uses a plugin system based on `importlib.metadata.entry_points` to register converters, each implementing a `DocumentConverter` base class with `accepts()`/`convert()` methods and a priority-based dispatch. The main entry points are the `MarkItDown` class (Python API), the `markitdown` CLI, and the MCP server's `convert_to_markdown` tool. Data flows from local files, streams, HTTP responses, or URIs through converter selection (by MIME type, extension, or content inspection) to produce Markdown output. External dependencies include many optional format-specific libraries (pdfminer.six, python-docx, python-pptx, openpyxl, etc.), external binaries (exiftool, ffmpeg), cloud APIs (Azure Document Intelligence, Azure Content Understanding), and an OpenAI-compatible LLM client for image captioning and OCR.
This repository is the openai/codex monorepo, which implements a local AI coding agent called Codex (also referred to as Codex CLI). It provides a terminal user interface (TUI), command-line interface (CLI), and a local app-server daemon that manages AI-driven coding sessions. The architecture is client-server: the TUI/CLI communicates with the local app-server via JSON-RPC over Unix sockets or WebSockets, while the exec-server handles sandboxed command execution with platform-specific security policies (macOS Seatbelt, Windows sandbox, Linux bubblewrap). The system is built entirely in Rust, with additional TypeScript and Python SDKs for programmatic access. It supports a rich extension ecosystem including plugins, skills, MCP servers, memories, and a guardian safety layer for approval workflows. The protocol layer is generated from Rust types into TypeScript schemas, ensuring type safety across the boundary. The codebase is well-structured, heavily tested, and follows modern Rust practices (async/await, trait-based abstractions, comprehensive error handling). It is not a data research project; there are no notebooks, CSV files, or ML pipelines.
Aider is a mature, well-architected CLI application that enables AI pair programming in the terminal. It integrates with 100+ LLMs via LiteLLM to help developers edit code in local git repositories. The system is built around a sophisticated coder abstraction that supports multiple edit formats (whole file, diff, search/replace blocks, unified diffs) to accommodate different LLM capabilities. The architecture is plugin-based with a clear separation between the main CLI loop, coder implementations, model management, and repository mapping. Aider automatically commits changes with sensible commit messages, provides linting/testing integration, and supports advanced features like prompt caching, voice input, and a browser-based GUI. The codebase demonstrates strong engineering practices with comprehensive testing, CI/CD pipelines, and careful dependency management. The repo map feature using tree-sitter for code analysis is particularly notable, providing intelligent context about codebases to LLMs. The project maintains high quality through extensive test coverage, pre-commit hooks, and automated benchmarking against coding tasks.
PDFMathTranslate is a production-grade CLI and GUI application for translating PDF documents while preserving scientific formatting (formulas, charts, tables, and fonts). It uses an ONNX-based layout detection model (DocLayout-YOLO) to understand document structure, supports OCR for scanned PDFs, and integrates with numerous translation services (Google, DeepL, OpenAI, Ollama, etc.). The system operates as a monolithic package with multiple entry points: a command-line tool, a Gradio web interface, a Flask+ Celery HTTP API, and an MCP server for AI assistant integration. Internally, it follows a pipeline architecture: input PDF → optional OCR → layout analysis → text extraction → translation (with caching) → typesetting → bilingual output PDF. Notable engineering patterns include a pluggable translation backend via a kernel registry, a configurable translator base class with retry and caching, and a singleton configuration manager. The code is well-structured with test coverage and CI/CD pipelines, though the dependency on a Git submodule for the 'precise' kernel introduces minor coupling risk.
Langfuse is an open-source LLM observability and evaluation platform. It provides tracing, prompt management, evaluations, datasets, experiments, monitors, and a public API for integrating with AI applications. The architecture is a monorepo with pnpm workspaces and Turborepo, consisting of a Next.js frontend (web), a background worker (Express + BullMQ), a shared package with types and server utilities, and an enterprise edition. Data flows from ingestion (REST API, OpenTelemetry, SDKs) into ClickHouse for high-volume analytics and PostgreSQL for relational metadata. Background jobs handle evaluations, batch exports, cloud billing, and integrations. The codebase is well-structured with extensive testing, a custom ESLint plugin, and reusable UI components. It is actively maintained with frequent migrations and feature additions.
CPA Manager Plus is a full-stack, self-hosted management panel for AI gateway proxies (CPA / CLIProxyAPI). It provides a rich React dashboard to monitor usage across multiple AI providers, manage credentials and API keys, configure provider-specific settings, automate quota cooldowns and account health actions, and inspect credential health via Codex/xAI probes. The Go backend persists all data in SQLite, runs background workers for data rollups, migrations, and collector polling, and exposes a comprehensive REST API. The codebase is well-structured with a clean layered architecture (HTTP handlers, services, repositories), extensive unit and integration tests in both Go and TypeScript, a demo mode with synthetic data, and i18n support. It is actively maintained with a rigorous release process and frequent updates.
genblaze is a production-grade Python monorepo SDK for orchestrating generative AI media pipelines — image, video, audio, text-to-speech, and chat — across 16+ provider integrations (OpenAI, Google Gemini/Imagen/Veo, NVIDIA NIM, GMICloud, Runway, Luma, Replicate, FAL, ElevenLabs, AssemblyAI, Hume, LMNT, Stability Audio, Decart, AtlasCloud). The public API is a chainable Pipeline/Step abstraction with batch, streaming, ingest, and agent-loop modes, plus a Click-based CLI (extract/verify/replay/index) for manifest inspection, a schema-first spec package generating TypeScript types from JSON Schemas, and ~30 runnable examples. Architecturally it is a monorepo: libs/core (genblaze-core) contains the framework (pipeline, providers, model registry, storage, media handlers, canonical hashing, signing, observability, webhooks), while each connector under libs/connectors/* is an independently versioned package registering itself via plugin entry points. Key entry points are Pipeline.run()/batch_run()/stream() for programmatic use and the genblaze command line; data flows through provider submit/poll/fetch_output lifecycles, optional caching, S3/B2 object-storage sinks with URL policies, and manifest generation that can be embedded directly into output media files. Two capabilities set this apart. First, provenance: every run produces a canonical, hash-verified Manifest (SHA-256 over deterministically serialized JSON), optionally Ed25519-signed, and byte-preservingly embedded into JPEG/PNG/WebP/MP4/audio files via XMP/atom splicing without re-encoding. Second, security and reliability engineering: SSRF protection with DNS pinning, credential redaction, ReDoS-safe pattern heuristics, ffmpeg injection escaping, configurable retry policies, model liveness probes, and discovery-aware validation (NATIVE/PARTIAL/NONE support levels) that reduces hardcoded slug rot. The project is actively maintained with unusually thorough tooling: golden hash-stability tests, a provider conformance test base class (~15 contract checks per connector), pin-parity and PyPI-metadata release gates, zizmor/dependabot CI, and live probe scripts that fail on API drift. Main risks are the inherent churn of 16+ third-party APIs (mitigated but not eliminated by mock-heavy tests) and a package/versioning layout complex enough that installs rely on documented make targets. Overall this is a strong, well-architected application SDK — suitable both for direct use and as a reference for multi-provider integration frameworks.
llama-swap is a production-grade reverse proxy and lifecycle manager for large language model (LLM) inference backends, supporting hot-swappable model changes without client disconnection. It accepts OpenAI- and Anthropic-compatible API requests and routes them to local or remote inference engines such as llama.cpp, vLLM, stable-diffusion.cpp, and audio.cpp. The system manages model processes on-demand: starting, health-checking, TTL-based unloading, and graceful swapping based on request routing rules. Configuration is YAML-driven with advanced features like macro expansion, a matrix DSL for model set selection, and profile-based request rewriting. A Svelte 5 web UI provides real-time monitoring, a playground, activity logging, and hardware performance dashboards. Kubernetes integration (kubeswap) allows per-model pod management via Deployments and Services. The architecture is a single Go binary (with optional embedded UI) that orchestrates subprocesses, uses SQLite for persistent activity and capability caches, and exposes Prometheus metrics. Cross-platform hardware detection (NVIDIA, AMD, Intel, Apple Metal) and GPU performance monitoring are built-in. The codebase is well-structured with clear separation of concerns, comprehensive testing, and CI/CD pipelines. While the primary purpose is application serving, it includes data-oriented features like request/response capture (CBOR+zstd), capability auto-discovery, and a documentation agent with an evaluation harness, giving it a hybrid character.
This repository is a community distribution and feature-extension framework for OpenAI's ChatGPT desktop application on Linux. It does not contain the core ChatGPT application itself; instead, it verifies, repackages, and patches the official signed upstream .deb package to produce customized builds for multiple Linux package formats (deb, RPM, pacman, AppImage, Nix, Gentoo ebuild). The system adds over 40 optional Linux-specific features—such as system tray integration, global dictation, computer-use automation (window management, accessibility, screenshots), desktop recording/replay, text-to-speech, proxy authentication, and UI tweaks—each gated behind a declarative feature manifest and applied via a sophisticated patch engine that modifies the Electron app bundle at build time. Architecturally, the project is a build/packaging/update framework. The core is a patch engine (scripts/patches/) that applies declarative descriptors to the upstream app.asar in phases (main-bundle, webview-asset, extracted-app). Features live under linux-features/ with standardized manifests (feature.json), patch scripts (patch.js), stage hooks, and tests. Performance-critical subsystems are implemented in Rust: a computer-use backend (window management, input simulation, accessibility tree), a record-replay backend (desktop session capture, timeline events, skill drafting), a text-to-speech MCP server, a global dictation helper, and a self-updating package manager daemon. The launcher (start.sh.template) orchestrates environment setup, feature hooks, and CLI dispatch. Key entry points include the installer (install.sh), the feature picker GUI (scripts/feature-picker.py), the patch runner (scripts/patches/runner.js), and the updater daemon (updater/src/main.rs). Data flows are primarily build-time: the upstream .deb is downloaded, verified via GPG/SHA256, extracted, patched, and repackaged. At runtime, features like computer-use and record-replay communicate with native Rust backends over MCP/JSON-RPC. The updater daemon runs as a systemd user service, polling signed APT metadata and performing transactional rebuilds with rollback support. External dependencies include the upstream OpenAI .deb package (the sole ground-truth source), Node.js for patching, Rust for native components, and various Linux system tools (systemd, D-Bus, GNOME Shell, X11/Wayland utilities, ydotool, wmctrl, xdotool, secret-tool). The build system uses Make, Docker for CI, and supports multiple package managers. The project is heavily dependent on the upstream bundle's minified JavaScript structure, which it manages through contract-based patching with drift detection.
Windows Copilot API is an unofficial Python library and OpenAI-compatible HTTP server that bridges the consumer Microsoft Copilot chat service. It uses a pure-HTTP driver with curl_cffi to impersonate Chrome and speak Copilot's WebSocket protocol, handling authentication, proof-of-work challenges, and Cloudflare Turnstile clearance in-process. A Playwright-based browser module enables interactive sign-in and scheduled clearance refresh. The server wraps the library behind FastAPI endpoints exposing /v1/chat/completions and /v1/models with full streaming support, rate limiting, and concurrency serialization to cope with Copilot's single-account constraints. Notable features include transparent token refresh, conversation persistence, and a diagnostic tool for session debugging. The codebase is well-structured, with clear separation of concerns across protocol constants, challenge solvers, models, and drivers. It demonstrates advanced reverse-engineering and browser-emulation skills.
OpenRath is a framework for building LLM-powered AI agent applications with a torch-like API design. It centers on the Session abstraction (analogous to a Tensor) that flows through Sandboxes (execution environments), Memories (persistent state), and Tools (callable operations), orchestrated by Agents and Workflows. The framework provides session lineage tracking, sandboxed tool execution, memory persistence, and LLM provider abstraction, enabling the creation of multi-agent workflows with durable state and traceable provenance. The architecture is modular and extensible, featuring pluggable backends for sandboxes (local, OpenSandbox) and memory systems (local, OpenViking), a registry pattern for dynamic backend loading, and lazy evaluation of sessions for performance. Key innovations include write-ahead logging for crash-resistant session persistence, resource-keyed parallelism for safe concurrent tool execution, and unified garbage collection across session, sandbox, and memory domains. The framework is designed for production use, with extensive testing, clear documentation, and active maintenance.
whisper.cpp is a high-performance C/C++ inference engine for OpenAI's Whisper automatic speech recognition (ASR) model, with additional support for a wide range of large language models (LLMs) via an integrated llama.cpp fork. The core library is dependency-free and uses the ggml tensor library to run on CPU, GPU (CUDA, Metal, Vulkan, OpenCL, SYCL, etc.), and specialized hardware (Apple Neural Engine, Hexagon DSP, etc.). It provides a clean C API, extensive language bindings (Go, Java, Ruby, JavaScript, Swift, etc.), and a rich set of example applications including a CLI transcriber, real-time microphone streaming, an HTTP server with OpenAI-compatible API, voice-controlled chess, and a talk-llama chatbot. The repository also includes model conversion scripts (PyTorch to ggml, CoreML, OpenVINO), quantization tools, and evaluation benchmarks (LibriSpeech, Earnings21). While primarily an application library, it contains research-oriented features like grammar-constrained decoding, beam search, and experimental model architectures. The codebase is actively maintained with a large community, though the sheer number of hardware backends and model variants introduces some maintenance complexity.
New API is a full-stack AI gateway/proxy service that provides a unified interface for multiple AI model providers (OpenAI, Claude, Gemini, etc.). It features user authentication and authorization, API key/token management with quota tracking and billing, administrative dashboard for configuration and monitoring, intelligent routing between providers, format conversion between different AI APIs, payment integrations, webhook support, and a playground for testing models. The backend is built with Go using the Gin web framework and GORM ORM, while the frontend is a React/TypeScript application built with Bun. The system implements a modular architecture with clear separation of concerns across controller, service, model, and relay layers.
The openai-python repository is the official Python SDK for interacting with OpenAI's API services. It provides both synchronous and asynchronous clients for accessing OpenAI's REST and WebSocket APIs, including chat completions, embeddings, image generation, audio processing, fine-tuning, vector stores, and admin organization management. The library is generated from OpenAPI specifications using Castiron, ensuring strong type safety via Pydantic models and TypedDict for request/response objects. Key features include streaming support, webhook verification, workload identity authentication, and modular resource organization. The SDK handles authentication, retry logic, pagination, and error handling transparently, making it suitable for production AI-integrated applications.
Microsoft Semantic Kernel is an AI orchestration SDK for building multi-agent systems, process workflows, and LLM-powered applications. It provides a unified abstraction layer over multiple AI providers (OpenAI, Azure, Google, Mistral, Ollama, HuggingFace, etc.) and supports function calling, plugin systems, prompt templates, memory/vector stores, and content safety filters. The framework is implemented in both Python and .NET with consistent architectural patterns. In production, the system acts as a library that developers embed into their applications. The central Kernel class manages service registration, plugin loading, and function execution. Agents (ChatCompletionAgent, AzureAIAgent, etc.) provide conversational interfaces with tool-calling capabilities. The process framework enables event-driven, multi-step workflows with state persistence. The filter system allows cross-cutting concerns like logging, moderation, and quality checks to be injected into function invocation and prompt rendering pipelines. Key entry points include the Kernel class, agent classes, ProcessBuilder for workflows, and various sample scripts. Data flows typically involve user input being processed by an agent or kernel, which invokes AI services via connectors, optionally calls plugins/functions, and returns responses. The framework relies on external AI services, vector databases, and optionally Dapr for distributed process execution. While primarily an application framework, Semantic Kernel includes data/research-oriented components such as vector store integrations, embedding generation services, and quality evaluation filters, making it a hybrid tool suitable for both production AI applications and experimental research.
aicommits is a CLI tool that automatically generates git commit messages using AI. It supports multiple AI providers (OpenAI, Together AI, Groq, xAI, Ollama, LM Studio, OpenRouter, and custom OpenAI-compatible endpoints) and offers both agentic generation (using tool-calling LLMs) and one-shot fallback for models that don't support tools. The tool reads staged git diffs, sends them to the configured LLM, and produces commit messages in various formats (plain, conventional commits, gitmoji, subject+body). It includes a git hook for seamless integration, a PR generation feature, config management, auto-update, and a VS Code extension. The architecture is a monolith CLI application built with TypeScript, using cleye for argument parsing, @clack/prompts for interactive prompts, and the Vercel AI SDK for LLM interactions. The codebase is well-structured with extensive tests, modern TypeScript practices, and careful handling of edge cases like large diffs, model fallbacks, and timeout management.
Kiln is a full-stack AI development platform for building, evaluating, and optimizing LLM-based tasks and agents. It provides a desktop application (Tkinter tray + FastAPI server) with a Svelte web UI, plus a core Python library and a cloud server component. The system supports the complete AI workflow: project/task management, multi-provider LLM orchestration via LiteLLM, evaluation with multiple judge types (LLM-as-judge, code eval, exact match, pattern match, etc.), synthetic data generation, RAG pipelines (chunking, embedding, vector stores), fine-tuning, prompt optimization, and Git-based project versioning. It also includes a 'Kiln Pro' cloud service for advanced features like copilot-assisted spec refinement and batch generation. The architecture is a monorepo with uv workspace, featuring extensive test coverage (unit, integration, e2e) and CI/CD pipelines. While the primary character is an application, it incorporates significant data engineering patterns for evaluation pipelines, synthetic data generation, and statistical analysis.
async-openai is a comprehensive, async Rust library providing typed access to the full OpenAI REST API surface. It covers all major endpoints including Chat Completions, the modern Responses API, Audio transcription/speech, Image generation/editing, Embeddings, Fine-tuning, Assistants (deprecated), Vector Stores, Realtime WebSocket sessions, Admin & Usage, Evals, Containers, Videos, and more. The architecture centers on a `Client<C: Config>` struct that dispatches requests through a configurable HTTP stack built on `reqwest`, `tokio`, and `tower` middleware. Each API group is a separate module with strongly-typed request/response structs, builder patterns via `derive_builder`, and first-class streaming support via SSE event streams. The library emphasizes flexibility and production readiness: it supports multiple OpenAI-compatible providers (Azure, Ollama, Gemini) through the BYOT (Bring Your Own Type) pattern, allowing users to swap in custom serialization for any endpoint. A powerful middleware system integrates with the Tower ecosystem, providing retry with exponential backoff, timeouts, and concurrency limiting. The codebase is fully compatible with WASM targets, with dedicated examples and CI. Over 40 example projects demonstrate real-world usage patterns including multi-turn reasoning, function calling, web search, and realtime audio sessions. Code quality is high: type definitions are meticulously crafted with serde tagging, feature flags for minimal builds, and extensive use of macros to reduce boilerplate. The project tracks OpenAI's rapidly evolving API closely, with deprecated endpoints (Assistants) clearly marked and a migration path to Responses API. While the large surface area and many feature flags add complexity, the overall engineering is clean, well-organized, and suitable for production use. The maintainers actively respond to issues and keep dependencies up to date, making this one of the most thorough and reliable OpenAI SDKs in the Rust ecosystem.
Notte is a full-stack web AI agent framework and browser automation SDK. The implementation is a multi-package Python monorepo: notte-core provides shared domain models, actions, error hierarchies, telemetry, and configuration; notte-browser implements Playwright/Patchright browser control, DOM snapshotting, scraping pipelines, and form-filling heuristics; notte-agent contains the LLM-driven agent loop, deterministic fallback, and workflow execution; notte-llm wraps LiteLLM with structured completions, retries, and a file-based prompt library; notte-sdk is the client for the hosted Notte cloud API with remote sessions, agents, vaults, personas, and serverless functions; notte-integrations adds notifiers and third-party CDP session providers. Primary entry points are `NotteClient` for cloud usage, `NotteSession` for local browser automation, and `Agent`/`AgentFallback` for autonomous and hybrid scripted-agent workflows.
Ask Molty is a Cloudflare Worker that serves as a documentation agent for OpenClaw. It accepts user questions via a chat API, builds a read-only workspace from pre-indexed documentation, source code, and GitHub issues/PRs, then uses OpenAI's chat models with tool calls (search_workspace, read_workspace, list_workspace, run_shell) to answer grounded in the workspace. The worker handles authentication via OpenClaw ID or GitHub session cookies, serves artifact files (e.g., github-search.jsonl) via a proxy, and includes robust error handling for timeouts, malformed data, and streaming. The codebase is well-structured with separate modules for auth, prompt, retrieval, and types, and includes a comprehensive smoke test suite that mocks network interactions to verify behavior.