iKy (I Know You) is a modular OSINT (Open Source Intelligence) aggregation platform built with FastAPI, Celery, Redis, and an Angular frontend. The system ingests a username or email and concurrently executes 26+ parallel tasks across social media, data breaches, search engines, and dark web sources, returning a structured JSON contract (module, param, validation, raw, graphic, profile, timeline, tasks) consumed by a visual graph/timeline UI. Key architectural patterns include a dynamic module registry that maps route names to Celery task paths, a decorator-based task wrapper (@iky_task) that centralizes dev-mode golden-file bypass, error classification, and performance logging, and a pluggable search provider orchestration layer. The codebase demonstrates a strong separation of concerns between API routing, task execution, and data enrichment, but suffers from fragile scraping logic (LinkedIn RSC parsing, TikTok SSR regex), heavy reliance on browser session cookies, and several deprecated external APIs (Twitter v1.1, FullContact). The project is actively maintained with an extensive test suite (~4K lines) and Docker Compose deployment, though many tests are heavily mocked and may not detect real API drift.
This repository provides an HTTP API service for interacting with the TON (The Open Network) blockchain. It acts as an intermediary, translating HTTP requests into calls to the TON blockchain via the tonlib library. The service is built with FastAPI and uses a pool of worker processes to communicate with TON nodes, handling load balancing and failover. It supports caching of responses via Redis to reduce load on the blockchain nodes. The service exposes both REST and JSON-RPC endpoints for a wide range of blockchain operations, including querying account information, executing smart contract methods, and sending transactions.
Agentic Security is an open-source LLM vulnerability scanner that probes AI endpoints for security weaknesses such as jailbreaks, prompt injection, data leakage, and sandbox escapes. It provides both a FastAPI web server (port 8718) with a Vue.js frontend and a Fire-based CLI (server, ci, init, ls, scan). The core scan engine sends adversarial prompts (text, image, audio) to target LLMs via configurable HTTP specs, classifies responses using a multi-layered refusal detection system (phrase-based, OneClassSVM, PII detector, LLM-as-judge, hybrid voting), and generates detailed reports with failure rates and cost metrics. The architecture is modular: LLM provider abstraction (OpenAI, Anthropic, LiteLLM), resilience primitives (rate limiter, circuit breaker, concurrent executor), plugin-based refusal classifiers, and a dataset registry supporting HuggingFace, CSV, Google Sheets, and dynamic transformations (stenography, encoding). It also integrates external red-teaming tools (Garak, Inspect AI) and includes reinforcement learning and Bayesian optimization for adaptive prompt selection. While primarily an application, it contains significant data/research components (ML models, datasets, refusal classification research) that support its scanning mission.
Violin is an open-source video dubbing application that transcribes speech from any video, translates it into one of 33 languages, synthesizes a native-sounding voice-over using TTS (Cartesia Sonic 3, ElevenLabs, or OpenAI), and remuxes the result into a new video with optional SRT subtitles and in-video Q&A. The system provides three interfaces: a CLI tool (`violin <input> <output> --language <lang>`), a FastAPI web application with a browser UI for upload/download and real-time polling, and a Claude Code skill for invocation from a Claude session. The architecture follows a five-stage pipeline (audio extraction → Whisper transcription → LLM translation → TTS synthesis → video/audio merging with speed alignment) orchestrated by a shared `dub_video` function. Both the CLI and the API worker call the same core pipeline, with parameterized callbacks for progress reporting and cancellation. The API supports bring-your-own-key (BYOK) or server-provided free trial, job persistence via the filesystem, SQLite-based usage statistics, and periodic cleanup of stale jobs and orphaned temp directories. Configuration is YAML-based with deep-merge defaults, supporting pluggable providers per stage. The codebase is well-structured with separate modules for each pipeline stage, reusable cost tracking, and a prompt management system with safe format interpolation. Notable craftsmanship includes the `CostTracker` dataclass for per-job wall-clock and dollar-cost telemetry, the `transcriber.py` segment merging/deduplication logic for Whisper output, and the `api/stats.py` SQLite-backed stats with schema migration. The main weaknesses are the absence of unit tests (no test directory found) and some internal coupling of pipeline components to the global config object. The monolithic SPA frontend is functional but not independently reusable.
Container Tool Kit (CTK) is a web application that provides a visual editor for Docker Compose and Kubernetes manifest files. Users can create and manage projects by dragging and dropping services, volumes, and networks onto a canvas, editing node configurations through detailed forms, and viewing the resulting YAML/JSON in a synchronized code editor. The backend is built with FastAPI and PostgreSQL, handling project persistence, user authentication (JWT-based), manifest generation (including calling kompose for Kubernetes), and project import from remote YAML URLs. The frontend is a React/TypeScript single-page application using jsPlumb for the interactive canvas, Formik for form management, and Monaco Editor for code editing. The application supports both anonymous and authenticated usage, with features like autosave, visibility toggles, and pagination for project lists.
FastRTC is a Python library that enables developers to build real-time audio/video streaming applications with minimal code. It provides a high-level `Stream` class that integrates with Gradio for automatic UI generation and supports both WebRTC and WebSocket protocols. The library includes built-in handlers for voice activity detection (VAD) via Silero, speech-to-text via Moonshine, text-to-speech via Kokoro/Cartesia, and turn-taking logic. It also offers TURN credential helpers for Cloudflare, Twilio, and Hugging Face. The architecture revolves around defining a handler function that processes media chunks, wrapping it with turn-taking decorators, and creating a Stream object that handles signaling, connection management, and UI rendering. The codebase is actively maintained with frequent commits and an extensive set of demos integrating with various LLMs and AI services.
proselint is a linter for English prose that checks style, usage, and common writing errors based on authoritative references like Garner's Modern American Usage. It operates as a Python library with a command-line interface (CLI) and a FastAPI web service. The architecture is a monolith: text input is tokenized and matched against a registry of checks (existence, preferred forms, consistency, etc.) using a pluggable regex engine (RE2 or Python re). Results are output as structured JSON or formatted text. The project also includes editor plugins (Sublime Text, CodeMirror), a pre-commit hook, and a Jekyll-based documentation site. While the core linting logic is well-architected with a clean check type system and configurable thresholds, the repository carries significant technical debt from vendored third-party code (an old CodeMirror distribution) and several unmaintained editor plugins. The codebase is actively maintained with CI/CD across platforms and Python versions, but the outdated dependencies and legacy components introduce medium technical drift.
TripStar is a full-stack, multi-agent AI travel planning platform. It uses a FastAPI backend with a modular agent system (trip planner, weather, hotel agents) orchestrated by a large language model, and a Vue 3 + TypeScript frontend with a dark glassmorphism UI. The backend provides REST APIs and WebSocket real-time status updates for asynchronous trip generation tasks. It integrates data from multiple sources: Xiaohongshu (via reverse-engineered signed API and SSR scraping), Google Maps, and AMap (with automatic fallback). The LLM extracts structured attractions from scraped text, plans itineraries, and repairs malformed JSON output. The system also includes user preference memory with weighted decay and TOP-K recall, a knowledge graph module, and export to image/PDF. The frontend features interactive maps, a budget panel, multi-city support, and a floating AI chat widget. The application is Dockerized with a multi-stage build and supports Chinese, English, and Japanese through i18n. The architecture is cleanly separated into backend services (agents, API routes, memory, map dispatcher, scraper), and frontend views (Home, Landing, Result, AIChat). The map dispatcher pattern provides a unified interface for geocoding and POI search across Google and AMap, and the memory manager implements a reusable preference-learning system. However, the codebase has technical debt: heavy reliance on Xiaohongshu's undocumented API (fragile), a monolithic 42k-token CSS file from Paper Kit 2 (2017) with deprecated techniques, and a complex ~2000-line Result.vue component. Dependencies are not fully locked, and the scraper's JavaScript signature engine may break with anti-bot updates. Overall, TripStar is a solid, functional application with several reusable patterns, but it carries moderate maintenance risks due to its external dependencies and some aging code. Note: This is a hybrid application with a strong data-crawling component (Xiaohongshu scraping and LLM extraction), but the dominant character is a production-ready web application with a clear user interface and API.
The repository is a suite of tools for UniFi network management, including a dashboard, Wi-Fi Stalker, Threat Watch, and Network Pulse. It's built using FastAPI, Python 3.9+, and utilizes a multi-stage Docker build. The application has a React-based frontend and uses a modular design with separate tools for different features.
This repository is a FastAPI + async SQLAlchemy reference implementation of an idempotent enterprise integration pipeline, explicitly labeled demo-grade rather than a production platform. Operators interact through REST endpoints covering idempotent message ingestion (five-branch deduplication: accept_new, accept_supersede, skip_duplicate, skip_stale, quarantine), simulated downstream delivery with retry classification, per-system circuit breakers, dead-letter queues, ambiguous-timeout handling with query-before-retry, audited operator replay, end-to-end record inspection, a dashboard health overview, and materialization/compaction jobs. Data flows from an ingestion write path through staging and production projections, then into delivery attempt logs, DLQs, ambiguous outcome queues, replay requests, and audit tables, with SQLite as the default database and PostgreSQL supported via a single environment variable change. The architecture is cleanly layered into routes, services, models, and schemas, with explicit bounded contexts for ingestion correctness, delivery resilience, and explainability. Seeded mock downstream systems make all delivery outcomes deterministic, which is appropriate for a demo harness. The codebase demonstrates good engineering practices: pure decision functions separated from DB side effects, flush-but-don't-commit transaction boundaries, append-only audit logs, and a comprehensive pytest suite covering scenario-based integration and unit tests. Notable caveats include placeholder rule-based correlation matching, some dead/duplicated schema definitions, a version mismatch between pyproject.toml (0.1.0) and the FastAPI app (0.7.0), and an unusual pyproject build-backend string that may break pip package builds. The repository appears maintained as of September 2026 with five open issues and modern dependency ranges. Technical drift is low: SQLAlchemy 2.0 async mappings, Pydantic v2, and current FastAPI patterns are used. While the application is not production-ready itself, several of its pure service modules are genuinely reusable building blocks for idempotency, retry, and correlation problems in other integration systems.
Wavefront is an enterprise AI middleware platform, open-source alternative to tools like UnifyApps and n8n. It provides a full-stack system for building, managing, and deploying AI agents, chatbots, voice agents, knowledge bases (RAG), and AI-powered workflows. The monorepo includes a Python FastAPI backend with a modular, domain-driven architecture (agents, tools, knowledge base, voice, triggers, auth, API proxy), a React/TypeScript management console, background workers (Celery, stream processors), and the `flo_ai` Python agent framework (LLM wrappers, Arium graph engine, tool system). The platform supports multi-tenancy, RBAC, cloud storage abstractions (GCP/AWS/Azure), and pluggable datasource and authenticator modules. While primarily an application, it incorporates RAG pipelines, image embedding services, and model inference, giving it a hybrid character with strong data engineering elements.
AgenticSeek is a private, local autonomous AI assistant built as an alternative to Manus AI. The system features a multi-agent architecture with six specialized agents (Casual, Coder, File, Browser, Planner, MCP) selected by a hybrid router using BART zero-shot classification and an adaptive few-shot classifier. It provides a React frontend, FastAPI backend with Celery, CLI with voice support, and Docker Compose orchestration for self-hosted services including SearxNG search and Redis caching. The codebase demonstrates solid engineering with clean abstractions for LLM providers (14+ options), tool execution, browser automation, and workspace isolation. It is under active development but shows signs of technical drift in deprecated components (llm_server, SerpApi-based web search) and fragile browser automation. The architecture is modular and contains several reusable patterns, though the codebase is tightly coupled to its specific agent system and has substantial external dependencies.
Hyper-RAG is a hypergraph-driven Retrieval-Augmented Generation (RAG) system designed to reduce LLM hallucinations by modeling beyond-pairwise correlations in domain knowledge. The repository provides both a Python library (`hyperrag`) and a full-stack web application with a FastAPI backend and React frontend. The core innovation is the use of hypergraphs to represent complex relationships among entities, outperforming traditional graph-based RAG methods like Graph RAG and Light RAG. The system supports multiple query modes: hyper (full hypergraph), hyper-lite, graph, naive, and direct LLM, with streaming responses. Architecture: The Python library (`hyperrag/`) implements the RAG pipeline: text chunking, entity extraction via LLM, hypergraph construction, vector embedding storage (NanoVectorDB), and query execution. The web UI (`web-ui/`) consists of a FastAPI backend (`main.py`) exposing REST endpoints for file upload, database CRUD, and HyperRAG queries, plus a React frontend with Ant Design and Graphin for interactive chat, hypergraph visualization, and settings management. Docker Compose orchestrates the frontend, backend, and Nginx reverse proxy. Key entry points: `hyperrag/hyperrag.py` (HyperRAG class), `service_api.py` (standalone API), `web-ui/backend/main.py` (FastAPI app). External dependencies include OpenAI/Azure/Bedrock LLM APIs, NanoVectorDB, tenacity, aiofiles, and various Python packages. The system is configurable via `config_temp.py` and `settings.json`. Data flows: Raw text (uploaded or provided) is chunked, entities and relationships are extracted via LLM, hyperedges are constructed, and embeddings are stored. Queries are processed by selecting relevant hyperedges and entities, constructing a context, and generating a response. The system caches LLM responses and supports real-time logging via WebSocket during embedding.
jsf is a Python library that generates fake data conforming to JSON schemas. It provides programmatic and CLI interfaces for creating realistic test data, supports custom data providers, maintains state for dependent data generation, validates output against schemas, and integrates with FastAPI for automatic API documentation. The architecture follows a modular design where each JSON schema type is handled by a specific class in jsf/schema_types/, with the core parsing logic in jsf/parser.py. The project uses Pants for building, has comprehensive test coverage, and maintains active CI/CD pipelines with automated releases based on conventional commits.
This repository is a hybrid collection centered around an n8n workflow search engine. The core application is a Python/FastAPI server that indexes and serves ~4,300 n8n workflow JSON files via a SQLite FTS5-backed API, with a static GitHub Pages frontend for browsing. The workflows directory contains a large collection of n8n automation templates covering hundreds of integrations (Slack, Telegram, GitHub, Airtable, etc.), most structured as simple trigger-to-action pipelines. Beyond the main search engine, the repo includes an AI-stack sub-project (Docker Compose for n8n + Agent Zero + ComfyUI), a medical education Next.js app (medcards-ai), Kubernetes/Helm deployment configs, and various utility scripts. The codebase is functional but largely boilerplate — the FastAPI server implements standard CRUD/search patterns with basic security (path traversal protection, rate limiting, CORS), while the workflow JSON files are community-contributed examples of varying complexity. The sub-projects (ai-stack, medcards-ai) appear aspirational rather than production-ready, with the medcards-ai being a well-documented but untested Next.js application.
FastUI is a Python/TypeScript framework for building web UIs declaratively from Python code, using React as the frontend renderer. The backend defines the entire UI as a list of Pydantic-validated component models, which are sent to the frontend via a REST API. The frontend (React) receives these component definitions and renders them using Bootstrap or custom components. The architecture enforces a strict separation of concerns: the backend describes the interface, the frontend implements the rendering. The project includes a Python package (fastui) with component models, form generation, authentication helpers, and a dev server; three npm packages (@pydantic/fastui, @pydantic/fastui-bootstrap, @pydantic/fastui-prebuilt) for the React frontend; and a demo application. The code is well-structured, fully typed, and includes comprehensive tests. However, the project has been officially declared inactive (see issue #368), so no further development is expected. The codebase remains functional and is a good example of declarative UI patterns, but reuse should account for the lack of ongoing maintenance.
This is a production-grade backend service for an enterprise AI platform, VoiceSageX, providing Retrieval-Augmented Generation (RAG), agent-based conversational AI, multi-agent orchestration, long-term memory, and model inference. Built with FastAPI, it exposes numerous RESTful endpoints under `/Voicecomm/VoiceSageX/` for knowledge base management (document parsing, chunk editing, vector indexing), agent chat (single and multi-agent with LangGraph), MCP tool integration, and model invocation. The architecture follows a modular, pipeline-oriented design: the RAG subsystem implements a clear stage-based flow (extraction, cleaning, splitting, vectorization, retrieval, reranking) with strategy and factory patterns, while the agent subsystem uses a class hierarchy (BaseAgent → HistoryAgent → MemoryAgent) and supports streaming. The system relies on PostgreSQL with pgvector for vector storage, external sandbox for code execution, and multiple model providers (OpenAI, Azure, SiliconFlow, Ollama). Configuration is environment-aware (dev/qa/prod) and loaded from JSON files. The codebase demonstrates solid engineering practices with async patterns, Pydantic models, and consistent error handling, though there is some duplication across similar API endpoints and potential dependency drift risks from langchain and langgraph versions.
This repository implements a full-stack content operations platform exclusively for Xiaohongshu (XHS), the Chinese social media platform. It provides a complete lifecycle for managing XHS notes: discovering content via search or URL crawling, saving to a local library, AI-assisted rewriting and title/tag generation, scheduling and publishing through XHS's Creator API, and monitoring engagement metrics. The system is built as a modern web application with a FastAPI backend (Python) and a React frontend (TypeScript, Ant Design), using SQLAlchemy for persistence and APScheduler for background job execution. The architecture is a monolith with clear separation of concerns: backend API routers for accounts, notes, drafts, AI, tasks, publishing, monitoring, and analytics; a service layer for business logic; and a set of adapters that encapsulate the reverse-engineered XHS API clients. The frontend provides a dashboard, discovery page, content library, draft editor, publish center, auto-ops scheduler, and analytics views. Authentication uses JWT tokens with refresh logic, and the system supports multiple XHS account types (PC web and Creator) via QR code or phone login. A notable aspect is the extensive reverse-engineering of XHS's anti-bot mechanisms. The codebase includes custom JavaScript modules for generating signatures (b1, MNS, X-S, X-T, websectiga, profileData) and browser fingerprint emulation, all executed locally via Node.js subprocesses. This allows the platform to interact with XHS APIs without a real browser, enabling automated content operations at scale. While the primary focus is on XHS, the platform abstraction layer (PlatformId enum, adapter interfaces) suggests an intention to support other social media platforms, though only XHS is currently implemented. The repository is a hybrid of application and data engineering: it is primarily a production-grade web application with scheduled tasks, user management, and a rich UI, but it also contains data pipeline elements such as crawling, normalization, and storage of XHS content for later analysis. The data models and analytics endpoints provide research-like capabilities (keyword tracking, engagement trends, benchmarks), but these are embedded within the application rather than forming a standalone data research project.
CoexistAI is a research assistant framework implemented as a FastAPI application that provides a suite of API endpoints for web search, YouTube and Reddit retrieval, geospatial mapping, git repository analysis, text-to-speech/podcast generation, and knowledge base creation from local files or crawled websites. It integrates with an MCP server for agentic workflows and supports pluggable LLMs (Google, OpenAI, Ollama, local) and embedders (Google, HuggingFace, Infinity). The architecture is monolithic with modular utility functions, containerized via Docker with a companion SearxNG instance for privacy-respecting search. The codebase demonstrates a hybrid nature: while primarily an application with explicit API entry points, its core purpose is to support research and data-gathering tasks, making it equally relevant for data research scenarios. Configuration is centralized, and the system includes a web-based admin UI for runtime parameter changes. Active development is evident from recent commits and numerous utility modules, though some global mutable state and fallback-heavy code indicate where the system has evolved rapidly.
DeepV-Ki is an AI-powered wiki generator for code repositories that combines a Next.js frontend with a FastAPI backend. The system allows users to input a repository URL and automatically generates documentation, architecture diagrams (Mermaid), and provides a RAG-based Q&A interface. It features multi-LLM provider support (OpenAI, Google Gemini, Azure, AWS Bedrock, Ollama), GitLab/GitHub/Bitbucket integration, asynchronous task processing with Celery, and multi-layer caching. The architecture follows a monorepo structure with clear separation between frontend (React/Next.js) and backend (Python/FastAPI) components, communicating via REST APIs. The system includes sophisticated authentication (SSO, session management), progress tracking, and real-time WebSocket communication for streaming AI responses.