Mem0 is a production-grade memory layer for AI agents, providing persistent, searchable, and updatable memory across sessions. It operates as both an open-source Python/TypeScript SDK and a hosted platform (api.mem0.ai). The core library abstracts away LLM providers (OpenAI, Anthropic, Groq, vLLM, etc.), embedding models, vector stores (over 20 backends including Qdrant, Pinecone, PGVector, Chroma, Weaviate, and many more), and rerankers behind a consistent config-driven interface. Memory operations (add, search, update, delete) support scoping by user, agent, session, or run, and leverage hybrid search combining semantic, BM25, and entity-boost signals with configurable reranking. The repository is architected as a monorepo with a clear separation of concerns: the core SDK packages (`mem0/` for Python, `mem0-ts/` for TypeScript), a self-hosted FastAPI server with a Next.js dashboard, CLI tools in both Python and Node.js, and a comprehensive plugin ecosystem for AI coding agents (Claude Code, Cursor, Codex, Kimi, Antigravity, Pi Agent, OpenClaw, etc.). Each integration follows a uniform hook adapter pattern, translating native agent events into memory operations via MCP servers or shared core modules. The platform backend includes authentication, API key management, telemetry via PostHog, and a webhook system for event-driven workflows. Key data flows: An application calls `memory.add()` with messages and metadata → the SDK extracts facts via an LLM → embeds them using the configured embedder → stores vectors and metadata in the chosen vector store. On `memory.search()`, the query is embedded, hybrid-scored against stored vectors (with optional reranking), and results are returned with relevance scores. The system supports temporal reasoning (timestamp filtering, memory decay), entity-based partitioning, custom categories, and feedback mechanisms to refine future retrievals. External dependencies include LLM APIs, vector databases, embedding services, and optionally Redis/SQLite for local history.
OGX (formerly Llama Stack) is a production-grade, open-source AI inference platform that provides a drop-in replacement for the OpenAI API. It is a multi-provider API gateway supporting chat completions, embeddings, the Responses API (agentic turns with tool use), vector stores, file processing, conversations, prompts, skills, and connectors. The system is built on a clean provider plugin architecture where inline (built-in) and remote providers (30+ including Anthropic, Bedrock, Gemini, Ollama, vLLM, NVIDIA) are registered via ProviderSpec and dynamically routed. The FastAPI server auto-discovers API protocols and generates routes with telemetry (OpenTelemetry), authentication, multi-tenancy, and ABAC access control. The repository includes a Next.js admin UI, a Python CLI, OpenAPI-generated client SDKs (Python, TypeScript), benchmarking tools (RAG eval, vertical scaling), and comprehensive integration tests with recording/replay. It is designed for self-hosted or cloud deployment with Kubernetes and Docker support.
Milvus is a high-performance, distributed vector database designed for AI applications such as vector similarity search, RAG pipelines, and hybrid search (dense + sparse). It follows a microservices architecture with components like proxy, rootcoord, datacoord, querycoord, datanode, querynode, indexnode, and streamingnode. The system uses a Write-Ahead Log (WAL) with multiple backends (RocksMQ, Kafka, Pulsar, Woodpecker) for real-time ingestion, and a C++ execution engine (segcore) for vector indexing and query processing. It supports a wide range of index types (IVF, HNSW, DiskANN, SCANN, etc.), scalar indices, full-text search via Tantivy (Rust), and advanced features like CDC replication, RBAC, and multi-tenancy. The codebase is primarily Go and C++, with Python test suites and Rust bindings. It is actively maintained with frequent commits, extensive tests, and a robust client SDK.
Vanna is an open-source Python framework that generates SQL queries from natural language using retrieval-augmented generation (RAG). It provides a modular agent architecture with a core `Agent` class that orchestrates LLM interactions, tool execution, and rich UI component streaming. The system supports multiple LLM providers (OpenAI, Anthropic, Gemini, Ollama, etc.) and vector store backends (ChromaDB, FAISS, Qdrant, Pinecone, etc.) for storing and retrieving training data (question-SQL pairs, DDL, documentation). It includes a comprehensive evaluation framework for comparing agent variants, a legacy Flask API for backward compatibility, and a modern Lit-based web component frontend that renders rich components (tables, charts, cards, progress bars) via SSE streaming. The architecture is highly extensible with dependency injection for lifecycle hooks, LLM middlewares, error recovery strategies, context enrichers, conversation filters, and observability providers. Key entry points include the `Agent.send_message()` async generator, the `ToolRegistry` for tool management, and server factories for Flask and FastAPI. The system relies on external dependencies for LLM APIs, vector databases, and SQL databases, all configured as optional extras. The codebase demonstrates strong engineering practices with clean abstractions, though it carries significant legacy code from a previous version and some placeholder implementations (e.g., MD5-based embeddings in Qdrant).
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.