This repository implements an OpenAI-compatible REST API proxy for Amazon Bedrock, enabling applications built for OpenAI SDKs to seamlessly use Bedrock foundation models without code changes. The FastAPI-based service translates standard OpenAI API calls (chat completions, embeddings, models listing) into Amazon Bedrock runtime invocations and returns responses in OpenAI-compatible format. The architecture supports two deployment options: Lambda with API Gateway (serverless, cost-effective) or Fargate with ALB (lowest latency, no cold starts). Key features include streaming responses via SSE, tool/function calling, multimodal inputs, prompt caching for Claude/Nova models, reasoning mode for Claude 3.7 and DeepSeek R1, and interleaved thinking for Claude 4 models. Infrastructure is managed via CloudFormation templates with proper IAM roles and Secrets Manager integration for API key authentication. The codebase demonstrates solid engineering practices with clean separation of concerns, proper error handling, and comprehensive feature support. However, the absence of test files and limited documentation reduce overall quality. The project is actively maintained with recent commits and up-to-date dependencies.
NyaProxy is a lightweight API gateway/proxy service built with FastAPI and Uvicorn that manages authentication, credential rotation, load balancing, rate limiting, and observability for HTTP APIs. It acts as an intermediary between clients and upstream services, injecting credentials, enforcing quotas, and providing features like retry logic, key quarantine, and request/response transformation. The system includes a web dashboard for monitoring traffic, metrics, and queue status, and exposes Prometheus metrics for external monitoring. The architecture follows a modular design with separate concerns: core proxy logic (queue-first request handling), traffic management (load balancing and rate limiting), configuration management (using Nacho for layered config and schema validation), services (metrics, state persistence), and a dashboard interface. Requests are processed via a priority queue with worker pools, enabling prioritization of retries and high-priority requests. State persistence saves rate limit windows and key cooldowns to disk using SHA256-hashed keys to avoid storing secrets, allowing survival across restarts. Key entry points include the CLI (`python -m nya` or `nyaproxy` script) and the main application factory in `nya/server/app.py`. The system relies on dependencies like FastAPI, Uvicorn, Pydantic, Nacho, and the Prometheus client, with explicit version pins in `pyproject.toml` and regular updates shown in the changelog. The codebase demonstrates strong engineering practices including comprehensive test coverage (unit and end-to-end), secure secret handling, and clean separation of concerns.
This repository is an AI-powered stock research platform that combines a full-stack application (FastAPI backend, React/TypeScript frontend, Electron desktop app) with extensive data/research capabilities. It ingests market data from over a dozen providers (Tushare, yfinance, AkShare, etc.) with priority-based fallback chains, performs AI analysis via LiteLLM (supporting multiple LLM providers), and generates structured research reports, decision signals, and backtesting results. The platform supports multi-agent discussions, strategy screening, portfolio management, alerts, and multi-channel notifications (WeChat, Feishu, Telegram, email, etc.). It covers 13 international markets with trading calendars and market phase detection. The architecture is a monolith with modular services, using SQLite per-workspace isolation. While primarily an application, it has strong data/research characteristics including a screening engine derived from AlphaSift, decision signal lifecycle with outcome tracking, and skill opinion weight calibration. The codebase is well-structured with extensive tests, CI/CD, and reusable patterns like the data fetcher base class and notification sender template.
PlumeLens (鉴翎) is a local bird photo analysis and culling workstation for bird photographers. It uses on-device ML models—YOLOv26l for detection, a custom 11-keypoint pose estimator, CLIPIQA+/HyperIQA for quality assessment, and DINOv3 with LoRA adapters for species classification—to process photos without any cloud upload. The system scans user photo directories (read-only), performs detection, pose estimation, quality scoring, and species identification, then presents a grading interface (reject/record/usable/select) with manual review and species override capabilities. Export supports JPG/RAW with XMP sidecars, and a geographic archive module visualizes species sightings on an interactive map with conservation status. The architecture is a desktop application split into an Electron+React frontend and a Python FastAPI backend. The backend runs as a subprocess managed by Electron, communicating via REST APIs and Server-Sent Events for progress. The ML pipeline is orchestrated in `engine/pipeline/manager.py` with ONNX Runtime and PyTorch inferences. The frontend uses React 19, TanStack Query, Zustand, and a virtualized grid for handling large photo sets. The application is packaged for macOS (arm64) via electron-builder and PyInstaller. While the primary delivery is a desktop application, the repository also contains extensive model training scripts, evaluation frameworks (`evals/`), and dataset preparation utilities, making it a hybrid project with significant research and data engineering components. Model integrity is enforced via SHA-256 manifest verification at startup, and all inference is deterministic with versioned pipeline hashes to invalidate caches on updates.
This repository implements a modern Automatic Number Plate Recognition (ANPR) pipeline as a production-ready application. It ingests images (via HTTP upload or WebSocket stream), runs detection using the `fast-alpr` library (YOLO-based ONNX model), performs OCR with `fast-plate-ocr`, applies post-processing (confusion-pair correction, Turkish plate format parsing, temporal majority voting), optionally tracks vehicles via an IoU-based multi-object tracker, and stores only HMAC-SHA256 hashed plate texts for privacy compliance. The system is exposed through a FastAPI REST API with WebSocket support and a HTMX web UI, plus a Typer CLI for inference and server management. It is containerized with Docker and publishes to PyPI and GHCR. The repository also contains a legacy directory (`legacy/`) with a complete YOLOv5 training pipeline for license plate detection, but that code is explicitly unmaintained and serves as historical reference only. The modern codebase is actively maintained, well-tested, and demonstrates strong software engineering practices including protocol-based abstractions, structured logging, Prometheus metrics, and privacy-by-design persistence.
Fastango is a uv-first CLI tool for generating production-ready FastAPI projects. It provides two template styles (simple, mvc), a curated integration catalog spanning auth, databases, payments, AI, observability, and deployment, and an interactive terminal playground for selecting components. The tool also includes a constrained AI generation mode that converts natural-language prompts into validated project plans using only supported templates, skills, presets, and integrations, rejecting unsafe or unsupported suggestions. Architecturally, Fastango uses a modular scaffold engine: a mutable ScaffoldPlan accumulates dependencies, files, environment variables, and documentation; a TemplateRenderer renders Jinja2 templates from packaged directories and inline specifications; and an IntegrationRegistry resolves aliases, conflicts, and preset expansions before applying integrations. The generator module separates deterministic rules from optional LLM provider adapters (Anthropic, OpenAI), merging suggestions after validation against the same registry. The codebase demonstrates strong engineering practices: type hints throughout, Pydantic v2 for configuration, Protocol-based integration contracts, and comprehensive tests including smoke tests for generated projects. The safety model—where provider output is always validated against a allowlist before writing files—is a notable design decision that prevents arbitrary code generation. The integration catalog is declarative and extensible, making it straightforward to add new integrations without writing imperative code.
Local Deep Research is a self-hosted, privacy-focused AI research assistant that performs deep, agentic research using multiple LLMs and web searches. It provides a full-stack web application (FastAPI + JavaScript), a programmatic API, and a Model Context Protocol (MCP) server. The system ingests user queries, decomposes them, executes parallel searches across web and academic sources (SearXNG, Google, arXiv, PubMed, Semantic Scholar, etc.), fetches and extracts content, evaluates evidence, and synthesizes reports with citations. It features per-user encrypted SQLCipher databases, a settings system with environment variable overrides, a RAG library with FAISS vector store, journal quality scoring, news subscriptions, and extensive security controls (egress policy, SSRF protection, credential scrubbing). The codebase is heavily tested with unit, integration, UI, accessibility, and security tests. It is a hybrid of a web application and a research data pipeline, but the dominant character is a production-grade application.
Jellyfish is an open-source, full-stack AI short drama studio application. It provides an end-to-end production pipeline for generating vertical short dramas from scripts: script parsing (division, element extraction, consistency checking), storyboard generation (shot breakdown, asset linking, camera language), image/video generation via multiple AI providers (OpenAI, Volcengine), and async task orchestration with Celery. The backend is built with FastAPI, SQLAlchemy 2.0 async, and Redis; the frontend uses React 18, TypeScript, Ant Design, and Vite. The application is production-oriented with Docker Compose deployment, GitHub Actions CI, and automated OpenAPI client generation. It emphasizes visual consistency through global seed, style inheritance, and asset reuse. While primarily an application, it includes a significant amount of AI/LLM agent code for script analysis, giving it a hybrid character with research-oriented structured extraction pipelines.
OpenUBA is a full-stack User and Entity Behavior Analytics (UEBA) platform for security anomaly detection, investigation, and response. It provides a complete lifecycle for ML models (install, train, infer, version, share) via a pluggable registry supporting OpenUBA Hub, GitHub, HuggingFace, and local filesystem. The platform includes a rule engine with a visual DAG-based builder (ReactFlow), case management, real-time dashboards, multi-backend visualization (matplotlib, plotly, bokeh, etc.), and an LLM-powered assistant. The backend is built on FastAPI with PostgreSQL, SQLAlchemy, JWT/RBAC authentication, and optional Spark/Elasticsearch integrations. The frontend uses Next.js 14 (App Router), Apollo Client (GraphQL), shadcn/ui, and Recharts. A Python SDK enables programmatic access to all features. The system runs on Kubernetes with a Kopf operator managing custom resources (UBATraining, UBAInference, UBAWorkspace, UBAPipeline) for containerized model execution in isolated Docker images per ML framework (sklearn, PyTorch, TensorFlow, NetworkX). While primarily an application, it includes research-oriented components like experiment tracking, feature store, and Jupyter notebook workspaces, making it a hybrid tool for both security operations and data science workflows.
OpenAgentd is a local-first, coding-focused AI agent platform that provides a desktop application (Tauri), mobile companion (iOS), browser-based UI (React/Vite), CLI, and an API server. The system orchestrates an agent loop with pluggable LLM providers (Anthropic, OpenAI, DeepSeek, Grok, Ollama, etc.), MCP tool integration, filesystem tools, code analysis, and a scheduler for recurring tasks. It features a dual backend architecture: a legacy Python/FastAPI implementation and a newer Rust v3 rewrite (axum-based) that is progressively replacing the Python version. The web frontend is a rich SPA with real-time streaming, workspace management, telemetry/observability dashboards, and extensive settings panels. The repository also includes code health analysis scripts, document chunking for RAG, and a comprehensive test suite across all layers.
FileCodeBox is a file and text sharing service built with FastAPI and Tortoise ORM. It allows users to upload files or text accessible via short codes, with features including time/count-based expiration, chunked uploads, pre-signed URLs for direct cloud storage uploads, and an admin dashboard for management. The architecture uses a modular design with separate apps for base functionality and admin, storage abstraction for multiple backends (local, S3, OneDrive, WebDAV, OpenDAL), and background tasks for cleanup. Key entry points include main.py (FastAPI setup), apps/base/views.py (public sharing endpoints), and apps/admin/views.py (admin interfaces). The service demonstrates solid engineering practices with reusable components like storage abstraction and security headers, though some areas like settings management and rate limiting show opportunities for improvement in distributed environments.
This repository is a full-stack application for building knowledge graphs from unstructured data using Large Language Models (LLMs). The backend, built with FastAPI and LangChain, ingests documents from multiple sources (local files, web pages, YouTube, Wikipedia, S3, GCS), chunks them, and uses an LLM to extract entities and relationships, which are stored in a Neo4j graph database. The frontend, a React/TypeScript application, provides a user interface for uploading files, configuring extraction (schema, LLM model, chunking), visualizing the resulting graph, and interacting with the data through a retrieval-augmented generation (RAG) chatbot with multiple retrieval modes (vector, graph, fulltext, hybrid). The system includes post-processing features like community detection, deduplication, and orphan node cleanup, as well as token usage tracking and evaluation metrics (RAGAS). While primarily an application with a web UI, it also contains experimental notebooks (GraphRAG, chunk size evaluation) that serve a data research purpose, making it a hybrid codebase with a dominant application character.
LoLLMs (Lord of Large Language Multimodal Systems) is a local, single-user web application for interacting with large language models. It provides a FastAPI + Socket.IO backend with a Vue.js frontend, supporting multiple model backends (bindings) such as llama.cpp, OpenAI, Anthropic, and Ollama. The system features a plugin architecture with 'personalities' (scripted AI agents), function calling, RAG capabilities, and services for text-to-image, text-to-speech, and text-to-video. It is designed for extensibility through zoos of bindings, personalities, services, and functions. While primarily an application, it includes some data/research elements like model scrapers and training scripts, but these are secondary to the core chat interface.
This repository is a full-stack marketing demo application powered by Google Cloud generative AI (Vertex AI Gemini, Imagen). It provides an end-to-end workflow for generating campaign content (emails, social media posts, website copy, images), analyzing audiences via natural language to BigQuery, and managing assets across platforms. The frontend is a modern Angular 17 single-page application with Firebase authentication and hosting, while the backend is a FastAPI Python service deployed on Cloud Run. Terraform infrastructure-as-code provisions all GCP resources including BigQuery datasets, Vertex AI Search datastores, Dialogflow CX agents, and Google Drive folder templates for content export. The application showcases marketing use cases like trendspotting via GDELT news summarization, audience insights using structured and unstructured data, and interactive image editing with inpainting/outpainting. While primarily a demo application, the repository also contains several Jupyter notebooks exploring model tuning, text-to-SQL, and clustering explanations, making it a hybrid resource for both application developers and data scientists.
ClawGuard is a security application designed to protect AI agent ecosystems through static code analysis, runtime monitoring, and sandboxed execution. The backend is a FastAPI server providing authentication (JWT), a code security check pipeline (AST scanning + sandbox execution with sys.settrace monitoring), and audit log storage in SQLite. The frontend is a single-page HTML dashboard with Chinese/English i18n, simulating a defense matrix with real-time feedback. The system demonstrates a multi-layered defense: static prevention (AST blacklist), dynamic detection (monkey-patched builtins, runtime behavior monitoring), and mitigation (timeout, permission errors). It is a well-structured, self-contained application with clear separation of concerns, though the frontend is monolithic. The code quality is strong, with reusable components in the core modules, but the overall architecture is tightly coupled to the specific security policy.
Exosphere is a reliability runtime for AI agents, providing a state-based workflow orchestration platform. The system consists of three main components: a Python SDK (`exospherehost`) for defining nodes and execution graphs, a FastAPI state-manager backend that handles state transitions, retries, cron triggers, and secret encryption, and a Next.js dashboard for monitoring and managing workflows. The architecture follows a microservices-like pattern within a monorepo, with the SDK acting as a client library and the state-manager as the central orchestration engine. Key capabilities include dynamic graph execution, infinite parallel fanout/unite patterns, configurable retry policies (exponential, linear, fixed with jitter), signal-based state pruning and re-queuing, and a graph-level key-value store. The system relies on MongoDB for persistence and uses Beanie ODM. The codebase demonstrates solid engineering practices with well-structured controllers, middleware for request ID propagation and exception handling, and a comprehensive test suite, though some tests are incomplete or skipped. The project is in early beta (v0.0.3b1) with active development and monthly releases.
Promnesia is a browser extension (Chrome/Firefox) paired with a Python backend that enriches browsing history with contextual metadata from personal data sources. The backend indexes visits from browser history, bookmarks, chat logs (Telegram, Signal, etc.), social media (Reddit, Twitter, Hacker News), note-taking apps (Hypothesis, Pocket, Instapaper), and plaintext files into a SQLite database. A FastAPI server exposes endpoints (`/visits`, `/search`, `/visited`) that the extension queries to annotate visited links and display a sidebar with visit context, timestamps, and highlights. The system uses URL normalization (canonical URLs) to deduplicate visits across sources and supports user-defined filtering and hooks. The architecture is split into a Python CLI (`promnesia index` / `promnesia serve`), a TypeScript browser extension built with Rollup, and Docker containers for automated indexing. While the core is a personal data application, it also serves as a data pipeline for aggregating and querying personal activity, giving it a hybrid character.
LunaVox is a high-performance, cross-platform text-to-speech inference engine specialized for Qwen3-TTS models. It provides a unified C++ core with Python bindings, offering multiple interfaces: a CLI (`lunavox`), a desktop GUI (customtkinter), an HTTP/WebSocket server (FastAPI), and a Python runtime API. The architecture separates model loading, tokenization, LLM-based talker/predictor generation (via llama.cpp), and neural audio codec decoding (via ONNX Runtime) into modular components. Voice modes include base, voice cloning from reference audio, custom speaker selection, and text-described voice design. The system is designed for low-latency streaming synthesis, with benchmarks showing real-time factors below 0.2 on consumer GPUs. It includes a comprehensive model conversion pipeline from HuggingFace to GGUF/ONNX formats, a build toolchain for compiling the C++ engine, and production-ready serving with Prometheus metrics and auto-batching. The codebase demonstrates strong engineering practices with cross-platform support, structured stats contracts, and bilingual documentation, though it carries some technical debt from vendored GGUF code and platform-specific workarounds.
This repository implements an agentic crypto trading platform called AI Market Maker (AIMM). Despite the name, the code is not a low-latency market-making engine; it is a multi-agent hedge-fund-style trading stack that combines LLM-driven research agents with deterministic quant logic for backtesting, paper trading, and live trading. The core execution path is a LangGraph workflow: nine Tier-0 specialist agents (monetary, news, TA, on-chain, order flow, etc.) produce structured signals, a weighted arbitrator fuses them into trade intents, a Risk Guard vetoes dangerous proposals, and portfolio management routes execution through an OMS with an in-memory or SQLite ledger. The platform includes a FastAPI backend with REST and streaming endpoints, a Next.js/React dashboard, Docker deployment, Alembic migrations, CI, and a large test suite.
Elysia is an open-source agentic platform that uses a decision tree architecture to dynamically select and execute tools for searching and reasoning over vector databases (Weaviate). The core is a `Tree` class that maintains conversation history, an environment of retrieved objects, and a decision loop: at each step, an LLM (via DSPy) chooses which tool to call based on the current state and user goal. Built-in tools include hybrid/semantic query, aggregate, summarization, visualisation, and linear regression; custom tools can be added via a `@tool` decorator or by subclassing `Tool`. The system preprocesses Weaviate collections to generate LLM-created summaries, field mappings, and statistics, enabling adaptive query formulation. The platform includes a full-stack web application: a FastAPI backend with WebSocket endpoints for real-time query execution, and a built Next.js frontend (served as static files) offering a UI for conversations, collection management, tree visualisation (React Flow), and feedback collection. The backend manages multi-user and multi-conversation state via `UserManager`/`TreeManager`, persists trees to Weaviate, encrypts API keys, and supports feedback-driven few-shot learning. A CLI entry point (`elysia start`) launches the API server.