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.
Witsy is a feature-rich desktop AI assistant built with Electron and Vue 3. It operates as a Bring-Your-Own-Keys (BYOK) client, aggregating dozens of LLM providers (OpenAI, Anthropic, Google, Ollama, etc.) into a unified chat, agent, and automation platform. The architecture follows a standard Electron main/renderer process split, communicating via IPC, with a Vue 3 frontend and a Node.js backend. Beyond basic chat, Witsy provides a sophisticated agent system supporting multi-step workflows, A2A communication, scheduling, and webhooks. It includes a full RAG pipeline (document ingestion, chunking, embedding, vector search), a plugin system for tools (MCP, code execution, web browsing, image generation), and extensive voice capabilities (STT/TTS with multiple providers). Data is persisted locally as JSON files within workspaces, with a vector database for semantic memory and document retrieval. A key differentiator is its automation layer, which can control the desktop (text selection, pasting, app detection) via platform-specific automators (macOS, Windows, nut-js). It exposes a local HTTP API and a CLI for external integration. The MCP (Model Context Protocol) client allows it to connect to a vast ecosystem of third-party tools. While primarily an application, it contains significant data engineering components (RAG pipeline, memory manager, deep research orchestrator) that are tightly integrated into the app's workflow. The codebase is well-structured with a strong emphasis on testing, though its massive feature surface and reliance on external APIs introduce inherent complexity and maintenance challenges.
ResumeLM is an AI-powered resume builder application built with Next.js 15, React 19, and TypeScript. It provides a SaaS platform for creating, editing, and optimizing resumes for tech job applications, featuring AI-assisted content generation, resume tailoring for specific job applications, ATS optimization, and cover letter generation. The application uses Supabase for authentication and data storage, Stripe for subscription management, and integrates with multiple AI providers (OpenAI, Anthropic, Google, etc.) via OpenRouter or direct API keys. The architecture follows a modular structure with separate concerns for authentication, dashboard, resume editor, admin panel, and settings, leveraging server actions for data mutations and a robust AI abstraction layer for model selection and usage tracking.
FeedCraft is a self-hosted feed processing service that transforms raw sources (RSS, Atom, HTML, JSON, search results, inbox pushes) into customized RSS feeds through composable processing pipelines called 'crafts'. The system is a monolith Go backend with a Vue 3 admin dashboard, exposing REST APIs for feed ingestion, transformation (AI-powered translation, summarization, full-text extraction, filtering), and aggregation into 'topic feeds'. The architecture follows a clean separation of concerns: source fetching/parsing, craft processing (atomic operations and flows), engine runtime, and administrative controllers. External dependencies include SQLite/PostgreSQL, Redis, an OpenAI-compatible LLM, a browserless service for dynamic content, and optional embedding APIs for semantic filtering. The codebase demonstrates solid engineering with interfaces for sources, parsers, crafts, and caching, though it carries some migration complexity from legacy craft models to newer ones.
SuperAgentX is a modular, open-source multi-agent AI framework designed for orchestrating autonomous agents that plan, act, and execute real-world workflows. It supports 100+ LLM providers (OpenAI, Azure, Gemini, Claude, Bedrock, Ollama, LiteLLM) and 10,000+ MCP tools via the Model Context Protocol. The architecture centers on `AgentXPipe` pipelines that sequence or parallelize agents, each composed of an `Engine` that wraps an LLM client and a set of tool handlers. Handlers are defined using a `@tool` decorator pattern that auto-generates LLM function schemas. The framework includes built-in human-in-the-loop approval channels (console, Slack, Teams), persistent memory with SQLite and vector stores (Chroma, OpenSearch), full observability via OpenTelemetry and SQL-based telemetry, and a CLI for project scaffolding. It also features a production-grade browser automation engine based on Playwright for tasks where APIs are unavailable.
Mindolph is a desktop knowledge management application built with JavaFX. It provides integrated support for mind maps, markdown, PlantUML diagrams, and CSV files, along with AI-powered features such as text reframing, summarization, and chat via various LLM providers. The application features a modular architecture with core, base, FX, and domain-specific modules, an event-driven communication system, a plugin/extension system for mind map operations, and a preference management system. Users can manage workspaces, search within files, and use reusable snippets.
Talkio is a local-first desktop (Windows/macOS/Linux via Tauri 2) and Android application for multi-AI group chat. Unlike a conventional ChatGPT wrapper, it orchestrates conversations where multiple AI models — OpenAI Chat Completions, OpenAI Responses, Anthropic Messages, plus DeepSeek/Groq/Ollama via compatible endpoints — converse together in one thread, each bound to a configurable persona/identity with its own system prompt and model selection. Core features include streaming SSE generation, an MCP (Model Context Protocol) client with both stdio subprocess (desktop) and custom streamable-HTTP transports, a tool-call loop supporting iterative tool execution, automatic conversation context compression, chat branching/regeneration, file attachment parsing (PDF/Word/Excel/images), and export to Markdown/PDF. All data is local: conversations persist in SQLite via the Tauri SQL plugin, while providers, identities, MCP servers, and settings live in localStorage.
TraceAI is a multi-language (Python, TypeScript, Java, C#) OpenTelemetry-based instrumentation SDK for AI/LLM applications. It provides drop-in auto-instrumentation for 50+ LLM providers, agent frameworks (LangChain, LlamaIndex, CrewAI, AutoGen, etc.), and vector databases (Pinecone, ChromaDB, Qdrant, etc.). The core library wraps SDK calls to capture structured spans with semantic attributes (tokens, model, messages, tool calls) and exports them via OTLP to any OpenTelemetry-compatible backend, with a default hosted backend at Future AGI. The architecture is a monorepo with per-framework packages that follow a consistent instrumentor pattern: register a tracer provider, instrument the target library, then make API calls. Key entry points are `register()` (Python/TypeScript), `TraceAI.init()` (Java), and `TraceAI.Register()` (C#). The SDK also includes context attribute propagation, PII redaction, evaluation tags, and configurable masking. While the codebase is well-structured and actively maintained, there is significant duplication across framework instrumentors and some tests rely on heavy mocking, which limits reusability of individual components.
SuperCoder is a local-first, open-source AI coding agent with a desktop application (Tauri + Rust + React) and a suite of backend services. The core agent (Rust crate) provides an LLM-driven loop with tool execution (file editing, bash, git, code search), subagent spawning, and an 'Auto' mode where an orchestrator LLM generates plans executed by worker agents. The desktop app offers a rich UI for agent interaction, diff review, file exploration, and permission management. A separate Go-based 'Context Engine' service indexes codebases into vector (Qdrant), graph (FalkorDB), and text stores, enabling semantic code search, dependency analysis, and automated PR review with risk scoring. The repository also includes a legacy v1 backend (Go) with workflow executors for Django/Flask/Next.js code generation and a workspace service for managing isolated development environments. While primarily an application, the context engine introduces data/research elements through its indexing pipelines, retrieval strategies, and code review analytics.
This repository is a comprehensive collection of examples, tutorials, and applications demonstrating how to use LanceDB (a vector database) for various AI/ML applications. It showcases patterns for retrieval-augmented generation (RAG), multimodal search, chatbots, recommendation systems, and AI agents. The repository contains both Python and JavaScript/TypeScript implementations, with many examples featuring web interfaces using Streamlit, Gradio, or React. While it serves as a valuable resource for learning LanceDB integration patterns, the quality varies across examples, and some content is marked as archived.
This is a self-contained tool for detecting third-party AI API model substitution by analyzing the statistical fingerprint of random number generation. The backend is a Python proxy server (http.server) that forwards requests to OpenAI/Anthropic endpoints, handles GitHub baseline retrieval with caching, and provides an auto-update mechanism. The frontend is a single HTML file with embedded JavaScript (no bundler) that handles all user interaction: calibration of official models, testing of unknown channels, quick one-click verification against pre-downloaded baselines, and multi-channel comparison. The tool uses cosine similarity and Jensen-Shannon divergence to compare distributions, with special handling for model-specific parameters (max_tokens vs max_completion_tokens). The code is functional and well-organized for a single-developer tool, but lacks modularity (everything in one HTML file, backend in one script) and has no test suite. The baseline data files are precomputed artifacts, not part of a live data pipeline.
This repository is a comprehensive, educational collection of 42+ Jupyter notebooks and runnable scripts demonstrating a wide array of Retrieval-Augmented Generation (RAG) techniques. It is primarily a data_research and educational resource, not a deployable application or library. The codebase serves as a practical cookbook for engineers and researchers, covering the full RAG stack from basic chunking and retrieval (e.g., simple RAG, BM25) to advanced methods like GraphRAG, Self-RAG, HyDE, RAPTOR, and agentic RAG. It also includes a dedicated evaluation framework with notebooks and reusable scripts for measuring faithfulness, relevance, and correctness using tools like DeepEval and custom LLM judges. The architecture is modular, with a shared helper_functions.py providing common utilities for PDF loading, embedding, and retrieval, and an evaluation/ module offering reusable evaluation pipelines. The runnable scripts in all_rag_techniques_runnable_scripts/ provide cleaner, class-based implementations of the techniques that are more suitable for integration into other projects than the notebooks themselves. While the code is well-structured for an educational project and demonstrates high craftsmanship in its reusable components, it is not designed for production deployment. Reproducibility is limited by the lack of a pinned dependency file and reliance on external API keys. The repository is actively maintained and highly influential (29k+ stars), making it a valuable reference for anyone building or evaluating RAG systems.
The Prompt Engineering Guide is a comprehensive, multilingual documentation site built with Next.js and Nextra that serves as an educational resource for prompt engineering with large language models. While the site itself is a web application, its core value lies in the extensive collection of tutorials, technique explanations, model-specific guides, and research summaries that constitute a structured knowledge base on effective LLM prompting. The repository includes interactive Jupyter notebooks that demonstrate practical applications of techniques like PAL, RAG, and ReAct, alongside hundreds of MDX pages covering topics from basic prompting to advanced agent building. Content is available in numerous languages, reflecting a commitment to global accessibility. The site features custom UI components for enhanced usability, such as announcement bars, course promotions, and copy-to-clipboard functionality, but these serve primarily to facilitate access to the educational content. Despite being actively maintained, the guide faces challenges typical of rapidly evolving fields: content requires frequent updates to keep pace with new LLM releases and research findings, and the multilingual nature increases the risk of translation drift. External links to papers, videos, and tools may also become stale over time. Nevertheless, the repository remains a valuable reference for practitioners and researchers seeking to understand and apply prompt engineering principles.
Eidolon is an open-source framework for building, deploying, and managing multi-agent AI applications. It provides a Python SDK with abstractions for LLM integration (OpenAI, Anthropic, Mistral, Ollama, Azure), retrieval-augmented generation (RAG) pipelines, memory systems (vector stores, symbolic memory, file storage), and document processing (loaders, parsers, splitters). Agents are configured declaratively via YAML and can communicate with each other, use tools, and stream responses. The framework includes a Kubernetes operator for production deployment, a web UI built with Next.js and React for chatbot interaction and developer tooling, and a TypeScript client library. It also features built-in agent types like SimpleAgent, RetrieverAgent, SQLAgent, and a Tree-of-Thought agent, along with logic units for web search, browser automation, and API integration.
gpttools is an R package that extends RStudio with large language model (LLM) capabilities for R package development. It provides a suite of RStudio addins for tasks such as generating roxygen documentation, suggesting unit tests, converting scripts to functions, and a Copilot-style ghost text writer. The package also includes a retrieval-augmented generation (RAG) system that scrapes documentation, creates embeddings, and indexes them for context-aware chat. It supports multiple AI providers (OpenAI, Anthropic, Perplexity, Cohere, Ollama, Azure OpenAI, Google) via a modular streaming handler pattern, and offers both cloud-based and local (sentence-transformers, Ollama) embedding options. The architecture is a mix of R functions, Shiny apps (settings, retrieval chat, data documentation), and Python integration via reticulate for local models. Key entry points include the addins, the chat() function, chat_with_context() for RAG, and the crawl() function for building indexes. External dependencies include the gptstudio package, various LLM APIs, and a Python environment for local embeddings. While primarily an application, it incorporates data engineering patterns for scraping, chunking, embedding, and indexing documentation.
DesignFlow Kit is an open-source, full-stack web application that provides an AI-powered UX/Product Design toolkit. It features 8 AI chat assistants for various design workflows (research, personas, journey maps, wireframes, testing, workshops, information architecture, and general analysis), a Kanban-style sprint board with drag-and-drop and voice recording, a dashboard for progress tracking, a catalog of 41+ integrations, and pre/post-design kits. The frontend is built with React 18, TypeScript, Tailwind CSS, and shadcn/ui components, using Wouter for routing and TanStack Query for data fetching. The backend is an Express.js server with Drizzle ORM and PostgreSQL (with in-memory fallback), integrating with OpenAI GPT-4o for streaming chat, Whisper for transcription, and Resend for email-based OTP authentication. The application is deployed as a monolith via Replit-specific integrations, though the core stack is portable. The codebase is well-structured with clear separation of concerns, but suffers from significant duplication across the 8 chat page components and relies heavily on static data files for tool/integration catalogs. No automated tests are present, and the OTP flow includes a visible demo code in development mode, signaling some immaturity. Overall, it is a functional and feature-rich tool with moderate reusability of its core components.
The OpenAI Cookbook is a sprawling collection of example code, notebooks, and guides for accomplishing tasks with the OpenAI API. It is not a single application but a repository of patterns. Its dominant character is data research and example code: it contains hundreds of Jupyter notebooks and Python scripts demonstrating embeddings, fine-tuning, RAG, agents, evals, MCP integrations, and vector database usage. The repo also includes full-stack demo applications (React/Next.js/Flask) for real-time translation, deployment management, and supply-chain copilots, making it a hybrid. There is no unified data lineage; instead, each example subsection defines its own data flow from API calls to local CSV/JSONL inputs. The quality is uneven: some eval harnesses and agent demos are well-structured, while many notebooks are scratchy and rely on inaccessible private data. The repository is maintained (last commit June 2026, CI workflows active) but shows medium technical drift, with some examples pinned to older library versions and many notebooks requiring manual environment setup.
This repository implements an AI-powered code review bot for GitHub. It listens for pull request events (opened, synchronize) and uses OpenAI's language models (or Azure OpenAI, GitHub Models) to automatically review code diffs and post inline comments and summary reviews. The system supports multiple deployment modes: a Probot-based GitHub App, a GitHub Action, an AWS Lambda function, and a Vercel serverless function. The core logic is in `src/bot.ts` (event handling, file filtering, review creation) and `src/chat.ts` (LLM API abstraction). The architecture is a monolith with adapter layers for each platform. External dependencies include the OpenAI/LLM API, GitHub API via Octokit, and minimatch for glob-based file filtering. The bot is configurable via environment variables for model selection, prompt customization, language, and file inclusion/exclusion patterns. It also implements an incremental review feature to reduce API costs by only re-reviewing files changed since the last bot review.
ChatGPT-web is a Svelte 5 single-page application (with a Tauri desktop wrapper) that provides a configurable chat interface for multiple large language model (LLM) providers, including OpenAI, Anthropic, xAI, Google Gemini, Mistral, APIpie, OpenRouter, OrcaRouter, and custom endpoints. The system handles streaming and non-streaming chat completions, image generation, token counting, pricing estimation, chat profiles with system prompt injection, and export/import of conversations. All chat history and settings are stored client-side in localStorage and IndexedDB, making it a private, self-contained frontend. The architecture is a client-only SPA with no backend; it relies entirely on browser fetch calls to provider APIs. The codebase demonstrates a clear separation of concerns between UI components (Svelte), state management (local storage stores), provider abstractions (provider definitions, request classes), and utility modules (token counting, image caching, settings schema). However, it shows signs of organic growth with tight coupling between modules, frequent `any` type casts, and comments referencing desired refactors. The bundled prompts CSV from the awesome-chatgpt-prompts project serves as a built-in prompt library. The project is suitable for developers wanting a customizable, private, multi-provider chat frontend, but reusing individual components requires careful extraction due to internal dependencies.
KEA Research is a full-stack multi-provider AI research chat application. The backend is a FastAPI service backed by SQLite/SQLAlchemy, exposing chat, admin, health, user, and TTS endpoints. The frontend is an Astro + TypeScript single-page app that stores chat history and pipeline data in IndexedDB, with a Bootstrap-based UI. Deployment is containerized via Docker Compose with nginx handling TLS and SSE-friendly proxying. The core product logic is a four-step research pipeline: initial multi-provider responses, Mixture-of-Agents refinement, peer evaluation, and a final KEA synthesis with facts, consensus, flagged claims, rankings, and confidence scores. A web admin panel manages providers, models, provider sets, users, and app settings, while the frontend supports research layers, bookmarks, notes, drafts, export, attachment ingestion, and text-to-speech via a Kokoro ONNX model.