Khoj is an open-source personal AI assistant functioning as a 'second brain' for interacting with personal knowledge bases. It provides a chat interface allowing users to converse with various AI models about documents, notes, and connected data sources (local files, GitHub, Notion). The system supports multimodal capabilities including image generation, code execution, voice input/output, and computer operation through a modular agent architecture. Khoj features a Python/Django backend with FastAPI for API endpoints, a PostgreSQL database with pgvector for vector storage and search, and multiple frontends including a web application (React/Next.js), desktop client (Electron), mobile app (Android), and plugins for Obsidian and Emacs. The architecture emphasizes separation of concerns with distinct modules for file processing, embedding generation, conversation handling, tool integration, and user management.
DeepTutor is a full-stack AI-powered learning companion that provides chat, problem-solving, research, visualization, and structured learning capabilities. The system features a modular architecture with a Python/FastAPI backend, Next.js/React frontend, and a CLI interface. It implements an agent-based system where capabilities like deep solve, deep question, and deep research are implemented as loop capabilities with access to tools such as web search, code execution, and knowledge base retrieval. The platform includes a three-layer memory system for contextual awareness, supports multiple RAG backends (LlamaIndex, PageIndex, GraphRAG, LightRAG, IMA), and enables integration with external knowledge bases (Obsidian, MarginNote 4) and partner agents (Claude Code, Codex). The application employs a plugin architecture for extensibility, allowing new capabilities, tools, and subagents to be added via entry points. Configuration is managed through JSON/YAML files with runtime overrides, and services are decoupled via provider abstractions for LLMs, embeddings, search, and media generation. Real-time communication is facilitated by WebSockets and an internal event bus (StreamBus). The system supports multi-user deployments with role-based access control, isolated workspaces, and grant-based resource sharing for skills, knowledge bases, and partners. Deployment options include local installation, Docker containers, and CLI-only mode. The codebase demonstrates strong engineering practices with extensive unit testing, clear separation of concerns, and reusable patterns such as the capability protocol, tool composition, and atomic file operations. While the system's feature richness introduces complexity, its modular design allows for selective adoption of components.
Langchain.rb is a Ruby gem for building LLM-powered applications with a unified interface to multiple LLM providers and vector databases. It provides a modular architecture supporting Retrieval Augmented Generation (RAG), AI agents with tool usage, document processing, and prompt templating. The gem includes a Rails engine for deep Rails integration and is actively maintained with frequent updates. The system enables developers to create interactive AI applications by combining LLMs, external tools, and vector search capabilities.
Manifold is an AI agent platform enabling multi-step workflow automation through teams of AI assistants. The system provides a chat interface for interacting with configurable specialist agents, a visual workflow editor (WARPP) for creating reusable automation, and an experimentation playground for testing prompts and models. Built with a Go backend and Vue.js frontend, it features extensible tool systems, layered memory architectures (belief, evolving, decision), MCP integration for external tools, and comprehensive observability via OpenTelemetry. The architecture emphasizes modularity with clear separation between agent execution, persistence, tool discovery, and memory subsystems.
GPT Academic is a comprehensive Gradio-based web application that provides a unified interface for interacting with 30+ large language models (both commercial APIs and locally-hosted models) with specialized tools for academic research workflows. The system's core architecture revolves around a plugin-based extensible framework where functionality is organized into 'basic functions' (simple text transformations) and 'crazy functions' (complex multi-step plugins for PDF translation, LaTeX processing, code analysis, internet search, etc.). The main entry point (main.py) initializes a Gradio Blocks interface with a modular layout, dynamic plugin loading, and a custom FastAPI server wrapper that adds authentication, file access controls, and WebSocket streaming capabilities. The codebase demonstrates sophisticated multi-threading patterns for concurrent LLM requests, with a bridge abstraction layer (request_llms/bridge_all.py) that normalizes communication across diverse model providers including OpenAI, Azure, Anthropic, Qwen, ChatGLM, Spark, and many others. The plugin system supports both simple function-based plugins and class-based plugins with configurable argument menus, state management via cookies, and hot-reloading. Notable architectural components include a vector database integration for RAG workflows, a multi-agent system built on AutoGen, real-time audio processing with Alibaba ASR, and a Docker-as-a-Service pattern for delegating media processing tasks. The repository contains extensive documentation (MkDocs-based), comprehensive test coverage for plugins, CI/CD pipelines for Docker image builds, and support for multiple deployment modes (pip, conda, Docker, HuggingFace Spaces). The codebase exhibits high craftsmanship in its LLM integration layer, with features like automatic key rotation, model-specific parameter handling, streaming response management, and sophisticated error handling with watchdog timers. The plugin template system and dynamic UI generation demonstrate good software engineering practices for extensibility.
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.
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.