AI/ML

Gradio42.5k★

No JavaScript, no frontend knowledge required. Apache 2.0, Python. Backed by Hugging Face (they acquired the company). The API is dead simple: define your function, specify input/output types, and Gradio generates the web interface. Supports text, images, audio, video, files, dataframes, and custom components. Share instantly via a temporary public URL or deploy permanently on Hugging Face Spaces for free. Fully free. No paid tier for the library itself. Hugging Face Spaces offers free hosting with some compute limits; paid Spaces start at $7/month for dedicated hardware. Solo ML engineers: this is how you demo your work. Build a model, wrap it in Gradio, share the link. Takes 10 minutes. Small teams: use it for internal tools and stakeholder demos. Medium teams: build it into your ML workflow for model evaluation interfaces. The catch: Gradio is built for demos and internal tools, not production apps. The generated UIs are functional but not customizable enough for customer-facing products. Performance degrades with concurrent users; it's running your Python function synchronously by default. For production ML serving, use a proper API (FastAPI + frontend) instead of a Gradio wrapper.

Ray42.5k★

Ray lets you scale Python code from your laptop to a cluster by adding a decorator to your functions. No rewriting your code, no learning a new framework. It handles distributed computing, model training (Ray Train), hyperparameter tuning (Ray Tune), model serving (Ray Serve), and reinforcement learning (RLlib). Fully free under Apache 2.0. The core engine and all libraries are open source with no feature gating. Anyscale (the company behind Ray) offers a managed platform, but self-hosting the full stack costs $0. The catch: Ray's "just add a decorator" marketing undersells the complexity. Distributed computing is hard, and Ray doesn't eliminate that; it manages it. Debugging distributed tasks, understanding memory management across workers, and tuning cluster resources requires real expertise. For single-machine ML, you don't need Ray. It earns its place when you need to scale beyond one box or orchestrate complex ML pipelines.

openai-python30.7k★

This is the official SDK. It's the library that turns API calls into clean Python code. Instead of writing raw HTTP requests, you call `client.chat.completions.create` and get structured responses back. What's free: The library itself is free. MIT license (technically Apache 2.0). Install with `pip install openai` and you're coding in 30 seconds. The library costs nothing. The SDK is well-designed. Typed responses, async support, streaming, function calling, vision. Every API feature is available with clean Python interfaces. Actively maintained, usually updated within days of new API features launching. The catch: the library is free but OpenAI's API is not. GPT-4o runs $2.50-10/million tokens depending on the model. A chatbot handling 1,000 conversations/day could cost $50-500/mo easily. And this SDK only works with OpenAI's API. If you want to switch providers later, you need to refactor. Consider using the OpenAI-compatible API format that many providers support, or a framework like LangChain that abstracts the provider.

Label Studio27.3k★

Draw bounding boxes on images, highlight entities in text, transcribe audio, or create custom labeling interfaces with a template system. It's the Swiss Army knife of data labeling. The community edition is free under Apache 2.0. You get multi-user support, a project system, customizable labeling interfaces, and import/export in every format (COCO, YOLO, spaCy, etc.). Self-host it with Docker and you're labeling data in 10 minutes. The catch: the free version is single-node only. Label Studio Enterprise (now called HumanSignal) adds team management, active learning, model-assisted labeling, RBAC, SSO, and analytics, but pricing requires a sales call. The community edition handles small-to-medium labeling projects well, but once you have 5+ annotators who need quality control and agreement metrics, you'll feel the feature gap.

Langfuse26.9k★

Langfuse is the observability platform for LLM applications: traces every call, measures latency and cost, tracks quality over time. It traces every LLM call, shows you the prompts, completions, latency, costs, and lets you evaluate output quality over time. Basically Datadog for LLM applications. You instrument your code (a few lines with their SDK), and suddenly you can see every prompt, every token count, every dollar spent, every hallucination, across your entire pipeline. This is one of the fastest-growing tools in the LLM infrastructure space. Self-hosting is free with no feature limits. Their cloud tier has a generous free plan (50K observations/mo) and paid plans starting at $59/mo for 1M observations. The catch: Langfuse is LLM-specific. If you need general application monitoring, use Datadog or SigNoz. And the space is moving fast. New competitors appear monthly. The evaluation features (scoring, human feedback) are good but still maturing compared to dedicated evaluation platforms.

MLX26.1k★

MQTT.js is the standard JavaScript MQTT client for IoT and real-time messaging, working in both Node.js and browsers. It uses the unified memory architecture (where CPU and GPU share the same RAM) so there's no copying data back and forth like you'd do with CUDA on NVIDIA GPUs. This matters because most ML frameworks were built for NVIDIA hardware. Running PyTorch on a Mac works but doesn't fully exploit what Apple Silicon can do. MLX does. The API is intentionally similar to NumPy and PyTorch, so the learning curve is gentle if you know those. MIT, backed by Apple's ML research team. Growing fast and gaining serious traction. The catch: Mac-only. If your production environment is Linux with NVIDIA GPUs, MLX doesn't help you there. It's best for local development, experimentation, and running models on Mac hardware. The ecosystem of pre-built models and integrations is growing but still much smaller than PyTorch/CUDA.

MLflow25.8k★

MLflow tracks the entire machine learning lifecycle: experiments, parameters, metrics, model versions, and deployment. It's version control for your ML work: every training run, every parameter, every result gets logged and compared. Apache 2.0. Backed by Databricks but open source. Four core modules: Tracking (log experiments), Projects (reproducible runs), Models (packaging), and Model Registry (versioning and staging). Python-first but supports R, Java, and REST APIs. Self-hosting is free and straightforward. Pip install mlflow, run the server, point your training scripts at it. SQLite backend for solo use, Postgres for teams. Docker images available. Databricks offers a managed MLflow with integrated compute, governance, and collaboration features. Pricing starts around $0.07/DBU (Databricks Unit) but the exact cost depends on your cloud provider and usage. Solo ML engineers: self-host, totally free. Small teams (2-10): self-host with Postgres, maybe 2-4 hours/month of ops. Growing teams (10-50): consider Databricks when you need RBAC and audit trails. Large orgs: Databricks or a dedicated MLOps platform. The catch: MLflow tracks everything but doesn't DO everything. You still need compute infrastructure, a feature store, and monitoring separately. And the Databricks integration is so deep that some newer features land on managed first.

OpenMAIC17.2k★

OpenMAIC creates multi-agent conversations where AI agents collaborate, debate, and teach. It's an open multi-agent interactive classroom where AI agents play different roles (teacher, student, devil's advocate) and you learn through their interactions, not just a chatbot Q&A. Built by Tsinghua University researchers, it creates immersive learning sessions with one click. The agents debate concepts, ask each other questions, and you can jump in anytime. It's backed by a published academic paper, so the pedagogy is research-grounded. AGPL-3.0 licensed. If you modify it and offer it as a service, you must open source your changes. The catch: this is an academic research project, not a polished product. The 'one click' setup still requires you to bring your own LLM API keys and the experience quality depends heavily on which model you use. AGPL-3.0 makes commercial deployment complicated. And the multi-agent approach burns through tokens fast. A 30-minute session with 3 agents is 3x the API cost of a single chatbot.

Weights & Biases11.1k★

Weights & Biases logs every detail of your ML experiments (parameters, metrics, outputs, hardware usage) and gives you dashboards to compare runs side by side. It's a lab notebook for machine learning that actually stays organized. MIT license, Python. Two lines of code to integrate: `wandb.init` and `wandb.log`. Works with PyTorch, TensorFlow, Keras, Hugging Face, and basically every ML framework. The visualization is where it shines: interactive charts, parameter importance plots, and run comparisons that MLflow's UI can't touch. Free tier: unlimited personal projects, 100GB storage. That's generous for solo work. Team plan starts at $50/user/month: RBAC, audit logs, team dashboards. Self-hosting exists (W&B Server) but it's enterprise-only. No free self-hosted option. You're on their cloud or you're paying for a private deployment. Solo ML engineers: the free tier is excellent. Use it. Small teams (2-10): $50/user/month adds up fast ($500/mo for 10 people). Compare against self-hosted MLflow at $0. Growing teams: the collaboration features justify the cost if experiment tracking is critical to your workflow. The catch: no free self-hosted path. Once your team grows, you're locked into per-seat pricing or an enterprise contract. MLflow gives you the same core tracking for free if you're willing to run it yourself.

civitai7.1k★

Civitai is the community hub for sharing Stable Diffusion models, LoRAs, and checkpoints. Think of it as GitHub for AI image generation models: browse what others have trained, download fine-tuned versions, and share your own. Self-hosting requires Docker, Node.js 20+, PostgreSQL, and a fair bit of setup. The docker-compose gets you running but managing model storage at scale is the real operational challenge. Most people just use civitai.com directly. Useful for solo creators experimenting with image generation or teams building products on top of community models. The platform itself is free and open source. The catch: the self-hosted version is meant for development, not production. The hosted platform at civitai.com is where the community and model library actually live.

torchtitan5.3k★

TorchTitan is the PyTorch team's framework for training large language models at scale. It combines PyTorch's distributed training primitives into a working system: data parallelism, tensor parallelism, pipeline parallelism, and activation checkpointing. Fully free, BSD-licensed, no cloud requirement. This is not a weekend project. You need multi-GPU clusters (H100 or equivalent) and familiarity with SLURM or cloud HPC to orchestrate across nodes. The project supports multiple architectures including Llama 3 and 4, DeepSeek V3, Qwen3, and Flux for image generation. It ships with configuration examples but expects you to already understand distributed training before you start. ML researchers and infrastructure teams training large-scale models from scratch have the cleanest PyTorch-native starting point available. Solo developers building on top of existing models have no use for this. It is infrastructure for teams running their own training clusters who want to stay in the PyTorch ecosystem. The catch: TorchTitan is a reference implementation, not a hardened production system. The APIs are bleeding-edge and change frequently.

awesome-free-llm-apis4.2k★

This is a maintained list of permanently free LLM API endpoints with API keys. Not trials, not 'free for 30 days,' but free-tier APIs you can actually build on. The list is organized by provider with rate limits, model availability, and key details. CC0 licensed, so you can do whatever you want with the information. The catch: 'permanently free' is a strong claim. Free tiers change. Rate limits tighten. Providers shut down. This is a living document that's only as good as its last update. And free LLM APIs often have significant rate limits. Fine for prototyping, not for production traffic. Always have a paid fallback for anything customer-facing.

python-genai3.7k★

python-genai is Google's official Python SDK for talking to Gemini models. One pip install, one API key, and you are making calls to Gemini 2.5 Flash, Pro, and the rest of the lineup. It supports both the free Gemini Developer API and enterprise Vertex AI deployments with the same client interface. The SDK covers text generation, image generation, file uploads, function calling, and async/sync clients. Setup is minimal: "pip install google-genai" and set your API key. Compared to OpenAI's Python SDK, the developer experience is similar, but Google's free tier is more generous. You get a real free tier for Gemini Flash that handles most prototyping and small-scale production. If you are building AI features and not married to OpenAI, this is worth evaluating. Gemini's context windows are massive (up to 1M tokens on some models), and the pricing on Flash is aggressive. The SDK itself is clean and well-documented. For teams already on Google Cloud, the Vertex AI path gives you enterprise controls without changing your code. The catch: the SDK is young and Google has a history of deprecating developer products. The ecosystem of third-party tools, tutorials, and community support is still smaller than OpenAI's. You are betting on Google's commitment to this API surface.

awesome-opensource-ai3.5k★

This is the 'awesome list' for AI. Models, tools, infrastructure, datasets, organized by category with brief descriptions and links to the actual projects. Awesome lists live or die by curation quality. This one focuses on 'truly open source,' not source-available, not 'open weights with a restrictive license.' That distinction matters when you're building on top of these tools. The list is maintained on GitHub and follows the awesome-re standards. The catch: awesome lists are snapshots. They go stale unless someone actively maintains them, and the growth spike suggests this was recently featured somewhere. The real question is whether it'll be maintained in 6 months. Also, 'curated' means one person's opinion of what's worth including; your needs might differ. Use it as a starting point, not a definitive source.

anthropic-sdk-python3.4k★

The Anthropic Python SDK is the official way to build with Claude: agents, content pipelines, code assistants. It handles authentication, streaming, tool use, message formatting, and all the API plumbing so you write application logic instead of HTTP requests. It's free to install and use. The SDK itself costs nothing. You pay for the Claude API calls you make through it. Streaming, tool use, vision, and batch processing are all supported out of the box. Type hints are excellent, which matters when you're building complex agent flows. The catch: this is the SDK, not the API. Your costs come from Anthropic's API pricing. Claude 3.5 Sonnet runs about $3/$15 per million input/output tokens. The SDK is tightly coupled to Anthropic's models. If you want multi-provider support, you'll need something like LangChain or LiteLLM on top. And breaking changes between SDK versions happen, so pin your version.

MOSS-TTS-Nano2.8k★

MOSS-TTS-Nano is a multilingual text-to-speech model with only 100 million parameters that runs in real time on a CPU. No GPU required. It handles English, Chinese, Japanese, and other languages with solid quality for its size. Small enough to embed in desktop apps, local demos, or lightweight web services. Runs via Python with standard ML dependencies. Models are available on HuggingFace and ModelScope. Finetuning is supported for custom voices. The deployment stack is intentionally simple: no CUDA required, no complex inference servers. A basic machine handles it. Free for everyone under a permissive license. Solo developers building voice features get real-time TTS without paying per-character API fees. Teams building products can embed it directly without usage limits. The catch: 100M parameters means tradeoffs in naturalness and expressiveness. If you need the best possible voice quality, larger models or paid APIs like ElevenLabs will sound better. This is the right choice when you need speed, low cost, and local execution over peak fidelity.

mike2.6k★

Mike is an open-source AI legal platform for document processing and review. Built on Next.js with an Express API, Supabase for auth and storage, S3-compatible object storage for files, and your choice of LLM provider for the analysis. AGPL-3.0. Setup is significant. You need a Supabase project, an S3-compatible bucket (Cloudflare R2 works), API keys for at least one model provider, and LibreOffice for DOC/DOCX-to-PDF conversion. The README is sparse, so plan for some reverse-engineering. Pick this if you run a small practice or a legal-ops team and want AI document review without sending client files to Harvey, Spellbook, or Casetext. Solo: free, you pay your model bill, the setup curve is real. Small teams: same plus shared infra. Large firms: they pay for Harvey because the integrations matter and they don't want to maintain this themselves. The catch: legal AI is a confidence and accuracy game, and Mike is early. Docs are thin, the feature set is whatever the README implies, and there is no SOC 2 posture out of the box. Use this because you want to own the stack, not because it's a turnkey product.

torchrec2.5k★

TorchRec is Meta's PyTorch library for training recommendation systems at scale. It is the engine behind the kind of "you might also like" model that runs on a feed of billions of items, packaged as a library you can use too. Free, BSD-3 licensed, used in production at Meta, Twitter, and Databricks. Running this means GPU clusters, sharded embedding tables, and pipelined training. It gives you the parallelism primitives (model sharding, communication kernels, a planner that figures out the layout) but you bring the recommender model and the data pipeline. Single-GPU experiments work fine, the value shows up when your embedding table no longer fits in memory. Solo: skip unless you are researching recsys at scale. Small teams: probably overkill, simpler libraries cover most product needs. Large teams shipping recommendations against tens of millions of items: this is what Meta built for itself, which is the strongest signal you will find. The catch is that this is infrastructure, not a recommender. You still need to know what model you are training, how you are sharding it, and how to feed it. TorchRec makes the hard parts possible, not easy.

daVinci-MagiHuman2.0k★

DaVinci-MagiHuman does it in one model. No separate video generation, no separate voice synthesis, no stitching. One 15-billion-parameter transformer takes text and a reference image and jointly produces video and audio. The numbers are real: 5-second 1080p video in 38 seconds on a single H100. Supports Mandarin, Cantonese, English, Japanese, Korean, German, and French. Beats Ovi 1.1 (80% win rate) and LTX 2.3 (60.9% win rate) in human evaluation. The full model stack is released: base model, distilled model, super-resolution model, and inference code. From Shanghai's GAIR Lab and Sand.ai. The catch: you need serious hardware. An H100 for the fast inference numbers, and the 15B parameter model isn't running on a consumer GPU. No license file listed; check before commercial use. And 'joint audio-video generation' is still early. The 5-second clip limit means this is for avatars and short-form content, not video production.

headroom1.7k★

headroom strips boilerplate from everything an LLM agent reads (tool outputs, logs, RAG chunks, file dumps) before the content hits the prompt. The reported numbers are real: 87% fewer tokens on a 100-log needle-in-haystack test, 92% on code search results, with accuracy unchanged on GSM8K and TruthfulQA. Apache 2.0, runs entirely on your machine. Setup is one command. `headroom wrap claude` or `headroom wrap codex` puts it in front of the API call. There is also a Python and TypeScript SDK for direct `compress(messages)` use, plus a proxy mode for everything else. Local-first design means no data egress, and compression latency is milliseconds, not a network hop. If you are paying for Claude, GPT, or Sonnet at scale, this pays for itself fast. Token costs drop directly. The hosted dashboard at headroomlabs.ai is a community leaderboard, not gated functionality. Solo developers running coding agents heavily: install it. Teams burning through enterprise LLM budgets: pilot on one team first. The catch: aggressive compression on novel content can lose nuance the model needed. The reversible design lets the model pull original bytes back via tool call, but that only works if the agent is configured to use it. Verify on your real workload before trusting blanket compression.

gemma-tuner-multimodal1.4k★

Gemma Tuner lets you fine-tune Google's Gemma 4 and 3n models on your Mac, no cloud GPU required. Text, images, and audio, all via Apple Silicon's MPS backend. You bring a CSV of training data, point the wizard at a HuggingFace checkpoint, and watch the training run on your local GPU with a real-time visualizer showing loss curves, attention heatmaps, and memory pressure. The 2B and 4B parameter models are the sweet spot for consumer hardware. 16GB RAM minimum, 32GB recommended. It streams training data from Google Cloud Storage or BigQuery for datasets larger than your SSD. Exports land in HuggingFace SafeTensors format with guides for Core ML and GGUF conversion if you want to deploy on-device. Solo ML practitioners get local fine-tuning without paying $2-5/hr for cloud GPUs. Small teams prototyping custom Gemma models can iterate locally before scaling to cloud training. The wizard CLI makes the setup approachable even if you're not a PyTorch expert. The catch: Gemma only. No Llama, no Mistral, no other model families. Larger Gemma weights (26B+) are not supported. Audio fine-tuning on non-Mac platforms requires CUDA. And you still need a HuggingFace account with Gemma's license accepted before you can download the weights.

pymilvus1.4k★

Pymilvus is the Python SDK for Milvus, a vector database purpose-built for that. Vector databases store data as mathematical representations (embeddings) so your app can find things by similarity rather than exact keyword matches. This is specifically the Python client library, not the database itself. You use it to connect to a Milvus instance, insert vectors, build indexes, and run similarity searches. The API covers everything: collection management, partitioning, hybrid search (combining vector similarity with traditional filters), and bulk data operations. pymilvus is free under Apache 2.0. Milvus itself is also free to self-host. Zilliz Cloud (the managed version from the Milvus creators) has a free tier with 2 collections and 1M vectors, then starts at ~$65/mo for production workloads. The catch: this is a client SDK, not a standalone tool. You need a running Milvus instance to connect to, and Milvus has real operational complexity. It requires etcd, MinIO, and message queues in production. If you just want to experiment with vector search, Chroma is dramatically simpler to get started with. For production vector search without the ops headache, Qdrant or Pinecone's managed service are worth evaluating.

llm-agents.nix1.2k★

llm-agents.nix packages every AI coding agent worth using as a Nix flake. Claude Code, Codex, Cursor Agent, Crush, Aider, GitHub Copilot CLI, Droid, Amp, Gemini CLI, OpenCode, and a dozen others all run via `nix run github:numtide/llm-agents.nix#claude-code`. MIT licensed, automatically updated daily. Nix users already know why this matters. Most AI coding agents ship as npm packages, curl-bash installers, or proprietary binaries that conflict with each other and bypass your shell environment. Wrapping them as Nix derivations means reproducible installs, no global pollution, and easy version pinning. The repo updates from upstream sources every day, so versions stay current without manual intervention. For Nix users running multiple AI agents, this replaces a directory of brittle install scripts with one flake. Solo: install it. Teams on NixOS: add it to your shared flake. Anyone else: not for you, this is Nix-specific tooling. The catch: most of these agents are themselves proprietary (Claude Code, Cursor, Copilot, Droid, Codex), so the Nix package is just a packaging convenience. You still need API keys, accounts, and licenses for the underlying services.

pyre-code1.0k★

Pyre-Code is a self-hosted coding practice platform for machine learning. 68 problems that walk you from implementing ReLU to building attention mechanisms, RLHF pipelines, and diffusion models. Browser-based editor with instant test feedback and reference solutions. No GPU required. Running it yourself takes a Next.js frontend and a FastAPI backend with SQLite for progress tracking. Standard Docker setup, nothing exotic. The whole point is to run it locally or on a team server so you can practice without leaking code to a third-party platform. ML engineers prepping for interviews or deepening their understanding of model internals will get the most from this. It's not a course or a tutorial: it's hands-on implementation practice where you write the code and the tests tell you if you're right. The catch: 68 problems is a fixed set. No community contributions yet, no problem editor, and the difficulty curve assumes you already know Python and basic linear algebra.