Yuxi – Self-Hosted Multi-Tenant Knowledge Agent Platform
Unify RAG, knowledge graphs, multi-agent orchestration, MCP/Skills, sandbox, and permissions in one self-hosted platform.
Evidence shows role-based access control (user/department permissions) and API key authentication, but no detailed implementation of least privilege. User confirmation mechanism not documented. Data flow transparency partial: README mentions retrieval sources backfilled as citations, but no data flow details. Sensitive data handling: API key authentication mentioned, but storage method not specified. Dependency security: no mention of vulnerability scanning or security audit. External effects: sandbox tools and file system mentioned, but sandbox isolation strength not specified. Rollback: not mentioned. Source attribution: README acknowledges several open-source projects, but no specific code references.
Self-consistency: README features align with code structure (e.g., FastAPI, LangGraph), but not deeply verified. Dependency availability: dependencies listed in README, but no version pinning or mirrors. Failure messages: test code has failure messages, but product docs do not explain error handling.
Audience and scenarios: README clearly states suitable for teams needing private deployment, organizational access control, multiple knowledge sources, and extensible agents. Capability boundaries: README states unsuitable scenarios (e.g., minimal single-document chat UI or fully managed SaaS). Trigger precision: no detailed description of agent trigger conditions. Environment fit: Docker Compose and LITE mode provided, but not all environment requirements.
Information architecture: README well-structured with navigation and doc links. Install notes: quick start steps provided, but no detailed configuration. Naming stability: no mention of API or config stability. Examples and FAQ: screenshots and demo provided, but no FAQ. Known limitations: not explicitly listed. License: MIT license, but third-party component licenses noted. Versioning and changelog: changelog link provided, but no specific content. Maintenance responsibility: no explicit maintainer or contribution guidelines.
Output usability: previewable, downloadable artifacts provided, but format not specified. Marginal value: knowledge graph and sandbox features compared to existing platforms, but not quantified. Cost-benefit: no performance or cost data.
Claim traceability: feature claims in README lack code references. Cross-source corroboration: no external verification. Fact-inference separation: no clear distinction between facts and inferences.
- No detailed implementation of least privilege; permission model needs review.
- Storage and encryption of sensitive data (e.g., API keys) not specified.
- Dependency security not mentioned; check for vulnerabilities.
- Sandbox isolation strength not specified; needs verification.
- Rollback mechanism missing; needs confirmation.
What does this agent do, and when should you use it?
Yuxi is a self-hosted, multi-tenant knowledge agent platform designed for teams. It combines RAG (Milvus-based), knowledge graphs (Neo4j and Milvus), LangGraph multi-agent orchestration, MCP/Skills, sandbox tools, and permission management in a single workbench. Administrators can connect model providers, build knowledge bases, and configure user and department permissions; users interact through a unified chat interface to access knowledge, tools, and subagents, receiving answers with source citations, graph-context reasoning, and downloadable artifacts. The platform deploys via Docker Compose, uses a Vue 3 frontend and FastAPI backend, and integrates DeepAgents as its deep agent framework. It acknowledges inspirations from LightRAG, DeerFlow, and RAGflow, and is licensed under MIT.
Yuxi runs a unified chat interface where users can ask questions and receive answers with source citations and knowledge-graph context. It executes LangGraph and DeepAgents-based agents, supporting subagents, Skills, MCP, tools, and middleware, with ARQ async workers for long-running tasks. Administrators configure model providers (OpenAI-compatible APIs) and API keys. The system extracts entities and relationships from knowledge-base documents, builds and retrieves knowledge graphs in Milvus and Neo4j, and visualizes subgraphs in the frontend. The sandbox provides an isolated filesystem where artifacts like text, images, PDFs, and HTML can be saved, previewed, and downloaded. The platform also includes user/department permission management, model provider configuration, and API key usage monitoring and evaluation.
- Enterprise knowledge management teams: need internal knowledge bases combined with graph reasoning to give employees accurate, cited answers via chat.
- AI application developers: want to integrate multi-agent, RAG, and knowledge graphs in a self-hosted platform to avoid external SaaS dependencies.
- Research institutions: require private deployment of knowledge bases and graphs to support literature retrieval and synthesis.
- IT operations staff: need multi-tenancy and user/department permission control to integrate the platform with existing model APIs.
- Document-heavy organizations: need to extract entities from documents and build knowledge graphs for complex queries.
- Teams requiring task delivery: use sandbox and tools to execute long-running tasks and generate downloadable artifacts like PDFs or HTML.
What are this agent's strengths and limitations?
- Integrates RAG, knowledge graphs, multi-agent, and sandbox into one platform, reducing integration overhead.
- Supports multi-tenancy and user/department permissions, designed for teams rather than single-user demos.
- Docker Compose provides a clear out-of-the-box deployment path.
- Artifacts can be previewed and downloaded, suitable for task delivery scenarios.
- MIT license allows commercial use and modification.
- Heavy dependency stack (PostgreSQL, Redis, MinIO, Milvus, Neo4j) requires significant resources.
- Requires at least one OpenAI-compatible LLM API, otherwise the platform cannot function.
- Early-stage project (v0.7.1) may have stability and documentation gaps.
- Sandbox security relies on Docker isolation; permission configuration is complex.
- Third-party components like Neo4j (GPL-3.0) and MinIO (AGPL-3.0) may impose license constraints on redistribution.
How do you install or deploy this agent?
Prerequisites: Docker and Docker Compose installed, plus at least one OpenAI-compatible LLM API.
- Clone and initialize:
git clone --branch v0.7.1 --depth 1 https://github.com/xerrors/Yuxi.git
cd Yuxi
# Linux/macOS
./scripts/init.sh
# Windows PowerShell
.\scripts\init.ps1- Start with Docker:
docker compose up --build- Access the platform: open http://localhost:5173 and log in with the admin account generated during initialization.
How do you use this agent?
After installation, log in with the admin account. Admins can configure model providers (OpenAI-compatible API), build knowledge bases (supporting multiple document formats), and set user/department permissions. Users interact through the unified chat interface, invoking knowledge bases, knowledge graphs, tools, subagents, etc. The system returns answers with citations and reasoning, and artifacts can be previewed and downloaded in the sandbox. For a lighter start without knowledge base/graph dependencies, use make up-lite to run in LITE mode for faster cold start. For detailed configuration, production deployment, and troubleshooting, see the project documentation (https://xerrors.github.io/Yuxi/intro/quick-start).
How does this agent compare with similar options?
The project references LightRAG, DeerFlow, and RAGflow as inspirations, but does not explicitly position Yuxi as a drop-in replacement. It can be seen as an integration and extension of these projects.
FAQ
What hardware resources are needed to deploy Yuxi?
How do I configure model providers?
How secure is the sandbox?
Does it support knowledge graph construction and query?
What are the limitations of LITE mode?
make up-lite) skips heavy dependencies like knowledge base and graph services, so those features may be unavailable. It is intended for rapid demos or testing.