AI/ML

ragflow87.0k★

RAGFlow is a retrieval-augmented generation engine built around deep document understanding, and it has grown into an agent platform sitting on top of that. It still handles the messy parts of RAG that other frameworks hand-wave past: PDFs with tables, slides, spreadsheets, scanned images, mixed-language docs, now with MinerU and Docling parsing. On top of that it added agent memory, an MCP server, and delivery into chat channels like Discord, Telegram, and Feishu. Apache 2.0. Self-hosting is a real project, not a `docker run`. You need 4-plus CPU cores, 16-plus GB RAM, 50-plus GB disk, and Docker. The compose file spins up the RAGFlow service plus a search backend (Elasticsearch, or their in-house Infinity vector DB) and MinIO for blob storage. The template-based chunking is still the killer feature: you can see and tweak how documents are segmented before they ever hit the index. Solo developers and small teams that want full control of their RAG pipeline can self-host this and feel good about it. Larger teams, or anyone without infra time, should look at RAGFlow Cloud, which gives you the same engine without the ops. The catch is operational weight. If you just need to chat with a few documents, LlamaIndex or LangChain over a simple vector store ships faster. Pick RAGFlow when document parsing quality, citation grounding, and now agent workflows over your own documents are the thing you are actually buying.

headroom65.3k★

headroom strips the bloat out of everything an LLM agent reads before it hits the prompt, tool outputs, logs, RAG chunks, raw file dumps, conversation history. The reported cuts are large, 60 to 95 percent fewer tokens with the same answers, and the compression is reversible, so the original is cached and fetchable when the model actually needs it. Apache-2.0, local-first, and free: your content never leaves your machine. You can adopt it at whatever depth you want. Drop the Python or TypeScript SDK inline, run it as a zero-code local proxy, or wrap an agent directly, Claude Code, Cursor, Copilot, and Aider all supported, plus an MCP server. It also trims the model's output, not just its input, through verbosity steering and effort routing, and headroom learn mines your failed sessions for auto-corrections. Development is fast-moving, this is not a stale side project. For anyone running agents on metered tokens, the math is simple: less context in and out means a smaller bill, and the local proxy makes trying it nearly free of effort. Solo developers and small teams: the open Apache-2.0 build is the whole tool, use it. Larger teams wanting shared deployment get a managed enterprise offering on top, which is where the money is, cross-team memory and central management rather than a better compressor. The catch is trust in the compression. Cutting 90 percent of the tokens only works if the 10 percent kept is the right 10 percent, and reversible caching exists precisely because sometimes it is not. Watch the first few runs on real work before you wire it into production blind.

LiteLLM55.8k★

LiteLLM is a proxy and Python library that puts a unified OpenAI-compatible API in front of 100+ LLM providers: OpenAI, Anthropic, Gemini, Cohere, Azure, Bedrock, Ollama, and more. Write your code once using the OpenAI format and switch providers by changing one line. Run it as a proxy server and you get rate limiting, cost tracking, fallback routing, and load balancing across providers. Teams use it to control which models engineers can call, track spend per team, and add retry logic without touching application code. MIT-licensed, free to self-host. Engineering teams building on multiple LLMs or managing costs across a company get the most value from the proxy. Individual developers using it as a Python library just want to avoid rewriting LLM calls when switching providers. Both use cases are free. The catch: the proxy adds latency. Not much, usually under 10ms, but it is a network hop. And the feature set moves fast enough that staying current requires attention.

Langfuse32.7k★

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.

Unlimited-OCR22.4k★

Unlimited-OCR is Baidu's open model for turning images and PDFs into text. Point it at a scanned contract, a multi-page report, or a screenshot full of text and it reads the whole thing in one pass, even very long documents. It handles single images, batches, and full PDFs, with streaming output so you see results as they parse. The weights are on Hugging Face and ModelScope under the MIT license, which means free to use, including commercially, with no strings. Running it yourself is where the cost shows up. This needs an NVIDIA GPU, CUDA 12.9, Python 3.12, and a recent PyTorch and transformers stack. You can run it through plain transformers or through SGLang for faster batch serving. It builds on DeepSeek-OCR, so the lineage is solid, but you are still standing up GPU infrastructure and a model server. There is no hosted API here, no dashboard, no support line. You bring the hardware. For solo work, the Hugging Face demo is free to try and you can run it on a rented GPU when you have a real job. Small teams that already process documents will want a dedicated GPU box or a cloud GPU. Larger teams treating OCR as a pipeline should put SGLang behind a queue. If you need OCR as a managed service with an SLA, look at a cloud vendor instead. The catch: MIT covers the code and weights, but accuracy on messy real-world scans is the thing you have to test on your own documents before trusting it. No benchmark replaces running it on your actual files.

OpenMAIC20.6k★

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.

civitai7.2k★

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.

awesome-free-llm-apis6.3k★

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.

awesome-opensource-ai4.4k★

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.

mike4.1k★

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.

MOSS-TTS-Nano4.1k★

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 now handles 20 languages, including English, Chinese, German, Spanish, French, Japanese, and Korean, with solid quality for its size. Small enough to embed in desktop apps, local demos, or lightweight web services. Apache 2.0. Runs via Python with standard ML dependencies, and there is now an ONNX CPU build that nearly doubles throughput. Models are on HuggingFace and ModelScope, finetuning code is published for custom voices, and recent additions include mlx-audio support for Apple Silicon and a browser reader extension. The deployment stack stays simple: no CUDA, no heavy inference server, 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 shipping 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 call when you want speed, low cost, and local execution over peak fidelity.

nixtla4.0k★

TimeGPT predicts where your numbers are headed. Feed it a history of anything measured over time, daily sales, hourly server load, weekly signups, and it forecasts what comes next and flags the weird spikes. No training a model, no feature engineering, three lines of Python. The SDK is open source under Apache-2.0. Here is the important part. The SDK is open, the model is not. TimeGPT runs on Nixtla's servers, and your data goes to their API to get a forecast back. There is nothing to self-host, which is why setup is trivial, but it also means you are sending your numbers to a third party and paying per call. A free trial key lets you kick the tires. For prototyping and one-off forecasts, the free trial plus a few lines of code is impressive, you get a working forecast in minutes. For production, you are on a usage-based bill and a hard dependency on their uptime. Solo and small teams testing an idea: start free. Teams putting forecasts in front of customers: price the API against running your own model with Nixtla's open StatsForecast or Prophet. The catch is the closed model. You cannot audit it, you cannot run it offline, and if Nixtla changes pricing or pulls the service, your forecasts go with it. Open SDK, closed brain.

daVinci-MagiHuman2.1k★

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.

edgequake2.1k★

EdgeQuake is a GraphRAG engine: it turns a pile of documents into a knowledge graph and combines vector search with graph traversal so an AI can answer multi-hop questions, the kind where the answer is spread across several documents. It's a Rust reimplementation of the LightRAG approach with a React UI, Apache-licensed and free. Running it is a real project. You need Postgres 16 with the pgvector and Apache AGE extensions, plus Docker Compose to wire it together. It also needs an LLM and embedding provider: point it at OpenAI or Anthropic and you'll pay per call, or run it against a local Ollama model for no API cost at all. For a developer building retrieval over their own documents who specifically wants the graph-plus-vector approach, EdgeQuake is a solid, self-hostable option, mostly solo and small teams comfortable with Postgres. The Rust core is fast and the code is documented. The catch is honesty about the payoff. On accuracy it's roughly a tie with LightRAG, so you're not buying a quality leap, you're buying a Rust implementation and a UI. And the pgvector-plus-AGE Postgres setup is a genuine dependency lift. If you just need basic RAG, a simple vector store ships faster. Reach for this when the graph structure is the point.

claude-real-video2.0k★

claude-real-video lets an LLM actually watch a video instead of guessing from a title. It pulls the frames that matter, using scene-change detection so it grabs a new frame when the picture changes, not every few seconds, deduplicates the near-identical ones, and optionally transcribes the audio with Whisper. Out comes a set of frames, a transcript, and a manifest you feed to Claude or any model. The core is MIT and free, and it all runs on your machine. Setup is a notch above pip-install because it leans on ffmpeg, the video-processing workhorse, which you install once at the system level. After that it is Python 3.10+ and a package install, with Whisper optional if you want transcription. Nothing leaves your laptop, which matters if the footage is sensitive. The free tier is the useful 90 percent: frame extraction, dedup, transcript. A one-time Pro unlock (founder price around $19, not a subscription) adds analysis on top, camera-movement classification, editing-rhythm detection, and a perception timeline of gestures and sound events. For most people wanting to hand a video to an LLM, free is plenty. Pay the $19 only if you are doing real video teardowns and want the extra structure. The catch is scope. This prepares video for a model, it does not understand it, the understanding still happens in whatever LLM you pipe the output into. It is a very good front door, not the whole house.

JoyAI-Echo1.9k★

JoyAI-Echo is JD.com's open release for generating long video with synced audio from a text prompt. Not the usual five-second clip. It targets multi-shot sequences up to about five minutes and keeps the same character and voice consistent across shots. The weights are actually released, not just a paper and a demo page, which is the difference between a real tool and a press release. The catch arrives fast on hardware. You're looking at roughly 46GB of VRAM for the full setup and around 70GB of weights to download. That's an H100 or A100, data-center territory. There are reduced settings for smaller cards, with the obvious tradeoffs in quality and length. Read the license before you build anything on this. It ships under the LTX-2 Community License, which forbids commercial use. So it substitutes for Sora, Runway, Kling, and Veo for research, prototyping, and personal projects, but not for anything you plan to sell. For commercial long-form video you're back to the paid services, or to a permissively licensed model like the Wan and Hunyuan families. Between a non-commercial license and data-center GPU requirements, this is a research showcase for most people, not a production tool. Impressive that it exists and runs. Just know what you can and can't do with it.

OnnxOCR1.8k★

OnnxOCR is a fast, multilingual OCR engine, the technology that turns images of text into actual text you can use. It is a rebuild of the popular PaddleOCR that strips out the heavy PaddlePaddle training framework and runs on ONNX Runtime instead, which makes it lean and quick. It reads Simplified and Traditional Chinese, English, Japanese, and more, and handles tables, document layout, and even license plates. Apache-2.0 and free. Setup is a pip install with Python 3.8 or newer. You can run it locally with a test script, stand it up as a JSON API, or launch a browser UI, and Docker support is included. Because it dropped the training framework, it runs well on edge devices and on both ARM and x86, which is the whole point: OCR without dragging a deep learning stack along. Accuracy is reported to match PaddleOCR 3.0. Developers who need to pull text from images or scanned documents and would rather not pay per-call cloud fees should look here. Solo and small teams get production-capable OCR for free, running on their own hardware. Larger teams processing high volumes save the most, since cloud OCR APIs bill per image. It is free at every scale. The catch is that you own the deployment and the accuracy tuning. Cloud OCR services like Google Vision or AWS Textract hand you an API and a support line; here you manage the models and the edge cases yourself. For high volume or privacy-sensitive work, that trade is usually worth it.

llm-agents.nix1.7k★

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.

gemma-tuner-multimodal1.5k★

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.

pyre-code1.2k★

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.

Boogu-Image940★

Boogu-Image is an open source image-generation and editing model you run yourself. It comes in Base, Turbo, and Edit variants for text-to-image, fast photorealistic generation, and image-to-image editing, with notably strong Chinese and English text rendering. Code is Apache-2.0 and the weights are on Hugging Face and ModelScope, all free. Self-hosting a model like this means real hardware. You need a capable GPU and the patience to set up inference, and there is no official hosted API to fall back on. At version 0.1 it is early, so expect rough edges. The payoff is full control and no per-image cloud bill, which adds up fast once you generate at volume. This is for ML practitioners and builders who want a permissively-licensed image model they can run on their own GPUs, especially if bilingual text rendering matters to them. Solo with a good GPU: free to run. Teams generating at scale: free software, but budget for the hardware. If you want a turnkey API and no ops, the proprietary options like DALL-E, Midjourney, Firefly, and FLUX Pro are where you pay for convenience. The catch is the hardware and the early stage. This is weights and code, not a service, so the GPU and the setup are on you, and at v0.1 it is more a capable starting point than a finished product. If you have the silicon and want to own your image pipeline, it is a strong free option. If you do not, an API is less hassle.