pgGraph is a PostgreSQL extension written in Rust (via pgrx) that adds high-performance graph query capabilities directly into PostgreSQL. It allows users to model graphs by registering existing relational tables as nodes and edges, building a compressed sparse row (CSR) adjacency index for sub-millisecond traversals, shortest paths, and connected components. The extension exposes SQL functions (`graph.traverse`, `graph.shortest_path`, `graph.search`, `graph.gql`, `graph.cypher`) and supports both openCypher and a subset of GQL for querying property graphs. It integrates deeply with PostgreSQL security (row-level security, multi-tenancy, ACLs), provides resource governance (memory, disk, work unit budgets), and includes a durable projection layer with atomic manifests, delta segments, compaction, and crash recovery. The codebase is structured as a pgrx extension with a Rust core, SQL bootstrap scripts, background workers for build/maintenance jobs, and an extensive test suite including fuzz targets, property-based tests, and heavy integration tests for concurrency, crash recovery, and performance gates.
VoltAgent is a large TypeScript monorepo for building, deploying, observing, and evaluating AI agents. The core package provides an agent runtime with tool calling, memory, subagents, guardrails, workflow orchestration, MCP client integration, A2A protocol support, voice, and OpenTelemetry-based observability. Framework adapters expose this runtime as HTTP/SSE/WebSocket servers via Hono, Elysia, and serverless function providers, while a CLI scaffolds projects and manages VoltOps deployment/auth flows. The repo is fundamentally an application framework, though it contains hybrid data-oriented subsystems: a RAG package with many document chunking strategies, vector adapters, and BM25 search, plus evaluation/scoring packages used for LLM benchmark experiments.
This repository is a comprehensive educational course titled 'AI Agents for Beginners', structured as a collection of Jupyter notebooks and code samples. It functions primarily as an ML notebook collection and tutorial suite rather than a deployable application or library. The content focuses on teaching the Microsoft Agent Framework (MAF) and Azure AI ecosystem, covering topics from basic agent concepts to advanced protocols like MCP and A2A. The codebase is organized into 18 lessons, each containing Python and .NET code samples, documentation, and images. It relies heavily on external cloud services (Azure AI Foundry, Azure OpenAI) and rapidly evolving AI standards, making it a high-quality learning resource but one with significant dependency volatility.
AG2 is a production-grade Python framework for building multi-agent AI systems. It provides a unified agent abstraction with support for multiple LLM providers (OpenAI, Anthropic, Gemini, Mistral, Bedrock, Ollama, xAI, Z.AI, DashScope), protocol integrations (A2A, A2UI, MCP, ACP), and sandboxed code execution (Docker, Daytona, local). The architecture is event-driven with a modular middleware pipeline, dependency injection, and a streaming event bus. It includes a full evaluation suite with trace reconstruction, scorers, pairwise comparison, and result persistence. The network layer enables distributed agent coordination via a hub-and-channel model with WAL persistence, identity management, and transport-agnostic envelopes. The framework also supports real-time voice interaction, skills-based toolkits, knowledge stores, and human-in-the-loop workflows. While the surface area is large, the codebase demonstrates high craftsmanship with clean abstractions, protocol-based interfaces, and extensive test coverage across all modules.
OpenAgents Control (OAC) is a framework for managing, testing, and orchestrating AI coding agents. It provides a CLI tool (`oac`) to install, update, and manage agents, context files, and skills from a registry. The system includes a plugin architecture for OpenCode and a compatibility layer that converts agent definitions between OAC, Claude Code, Cursor, and Windsurf formats. A comprehensive evaluation framework tests agent behavior against critical rules (approval gates, context loading, stop-on-failure, delegation, tool usage) using YAML-defined test suites and timeline-based analysis. The repository is primarily a software development toolchain for AI-assisted coding workflows, with strong emphasis on deterministic safety rules and multi-agent coordination.
PraisonAI is a production-oriented, multi-language AI agent orchestration framework shipped as a monorepo of cooperating Python, TypeScript, and Rust packages. The core SDK (`praisonaiagents`) implements `Agent`, `Task`, `AgentTeam`, and `AgentFlow`/`Workflow` abstractions with MCP support (stdio/HTTP/WebSocket/SSE), integration with 20+ LLM providers via LiteLLM-style configuration, memory backends (SQLite, file, mem0, MongoDB), RAG/knowledge bases over vector stores, guardrails, approval flows, policy engines, context compaction, telemetry, background jobs, and durable run ledgers. A user-facing `praisonai` wrapper provides a Typer CLI (`run`, `chat`, `code`, `serve mcp`, agent-as-API), bot adapters for Telegram/Discord/Slack via a WebSocket gateway, sandboxed compute (Docker, E2B, Modal, Daytona), deployment registries, cloud managed agents, and a fine-tuning package (`praisonai-train`). The repository is decisively an application/framework, though it carries data-research features as part of the product surface (RAG pipelines, evaluation loops, synthetic-data generation, LoRA fine-tuning), making it a hybrid in feature terms only.