alibaba/UnifiedModel

The semantic layer that makes enterprise data understandable to AI agents — model entities and relations once, query through SPL/MCP/REST, and connect telemetry, services, and business objects in one object graph.

📦 Project: alibaba/UnifiedModel (UModel)

UModel (Unified Model) is an open‑source, vendor‑neutral semantic runtime that lets enterprises expose their data, services, and topology as a single, queryable graph. It is designed so that human users, software systems, and AI agents can all read and act on the same shared model via a local service, REST API, CLI, SDKs, or a web UI.

🎯 What it does

  • Model Packs – Define enterprise objects (entities, datasets, links, storage, topology) in a declarative package.
  • Unified Query Surface – One query language (.umodel, .entity, .topo) that returns model definitions, runtime entities, and topology relations.
  • Agent Integration – Built‑in AgentGateway and MCP (Model Control Protocol) let LLM‑based agents discover services, follow relationships, and run model‑guided root‑cause analysis without hand‑written queries.
  • Local Service + UI – Runs as a single local process (or Docker/Compose) exposing a React web UI for exploring the workspace.
  • Public Contracts – OpenAPI spec, CLI (umctl), and generated SDKs (Go, Python, Java) let any client interact without touching internal code.

🛠️ Core components (as described in the README)

Component Role
Model Packs Vocabulary of entities, datasets, links, storage, and semantics.
EntityStore Persists runtime entities and topology edges that instantiate the model.
Query Service Unified read‑only surface for the three SPL domains (.umodel, .entity, .topo).
AgentGateway / MCP Exposes discovery, resource, and safe‑tool endpoints for AI agents.
Web UI Browser‑based explorer for models, entities, queries, data stores, and agent views.
CLI (umctl) Command‑line interface for managing workspaces, agents, and queries.
SDKs Auto‑generated Go, Python, and Java clients that wrap the public REST contracts.

🚀 Quick‑start (5 minutes)

  1. Prerequisites – Go 1.22+, Node 22+, make, and pnpm (or npm). Verify with make check‑env.
  2. Launch – make quickstart spins up the API, the UI, and loads a demo workspace (GRAPHSTORE=memory).
  3. Explore – Open http://localhost:5173, pick the demo workspace, and browse the Explorer, Query, Data Store, and Agent tabs.
  4. Agent demo – Run umctl agent discover demo and connect an MCP client (umodel-mcp) to see an AI agent walk the graph, pull metrics, and fetch logs automatically.
  5. Shutdown – make stop-all stops everything and cleans up the in‑memory data.

Full guides are linked in the repo (installation, web‑UI, query service, MCP reference).

🤖 Agent Skills

UModel ships loadable skill files (SKILL.md) for popular LLM‑based agents (Claude Code, Qoder, Codex, Cursor, etc.). Installing the skill package enables the agent to:

  • Read any entity, relation, or model definition.
  • Follow RunbookSet links to execute operational runbooks.
  • Perform model‑guided root‑cause analysis across the enterprise graph.

Installation example for Claude Code:

/plugin marketplace add alibaba/UnifiedModel
/plugin install umodel@unifiedmodel

(Other agents copy the same SKILL.md files into their skill directories.)

📚 Documentation & Examples

  • Bilingual docs – English and Chinese indexes (docs/README.md).
  • Concepts – Object‑graph semantic layer, model authoring, entity writes, query service.
  • Examples – Multi‑domain quick‑start pack, incident‑investigation demo, service‑localization demo (all show AI agents using the model).
  • Deployments – Docker and Docker‑Compose scripts for local or containerized runs.

🏗️ Architecture snapshot

UModel runs a workspace‑scoped graph in memory or persisted via a GraphStore provider (memory, file.memory, local.ladybug).

  1. Model Packs → define schema.
  2. EntityStore writes runtime data.
  3. Query Service offers the unified SPL surface.
  4. AgentGateway / MCP expose discovery and safe tool endpoints for agents.
  5. Clients (Web UI, CLI, REST, SDKs) all talk to the same public contracts.

The README includes a diagram (images/architecture.png) and deeper docs on runtime flow and query/agent interaction.

📦 Build & Contribute

  • Build – make install-env && make build.
  • Test – make guard, make test-service, make verify, make example-validate.
  • CI – make ci runs the full gate.
  • SDK generation – Go and Python SDKs under sdk/; Java SDK under generated/java/.
  • License – Apache‑2.0, with contribution and security policies provided.

🌟 Who might use this?

  • Enterprise AI teams needing a shared, vendor‑neutral semantic layer for data, services, and observability.
  • Ops / SRE groups that want AI agents to automatically discover services, trace dependencies, and run root‑cause analysis.
  • Product engineers building multi‑agent workflows that require a common “world model”.
  • Developers looking for a local, extensible graph runtime with public contracts and language SDKs.

📌 Bottom line

UModel is a full‑featured, open‑source platform that turns disparate enterprise schemas into a single, queryable graph usable by humans, programs, and AI agents. It provides the runtime, UI, CLI, REST API, and language SDKs needed to build semantic, agent‑driven operations without locking into any specific vendor stack.

Related

  • Project
    modelscope/ms-agent

    MS‑Agent is a lightweight Python framework for building autonomous LLM agents with tool‑calling, memory, multimodal input, and a skill‑retrieval system. It uses ModelScope’s Model Calling Protocol (MCP) for LLM access, provides a React/FastAPI web UI, and includes ready‑made projects for code generation, short video creation, and deep‑research workflows.

  • Project
    shibing624/agentica

    Agentica is an open‑source, Apache‑2.0‑licensed Python framework that lets you run LLM‑based agents locally. A single chat session becomes an autonomous agent that can call built‑in tools (search, file I/O, code execution, OCR, image generation), remember past work, and spawn sub‑agents or delegate whole tasks. It works via a CLI, a local web UI, a desktop app, and IM gateways (WeChat, Feishu, Telegram). Supports many model providers (OpenAI, DeepSeek, Claude, Ollama, etc.), offers async‑first APIs, safety guardrails, multimodal input, persistent memory, a markdown‑based skill system, and RAG integration. Install with `pip install -U agentica` (add `[gateway]` for the web UI) and configure an API key. Ideal for developers, researchers, and power users who want a self‑hosted “LLM OS” with collaborative multi‑agent capabilities.

  • Project
    Besty0728/Unity-Skills

    UnitySkills is a Unity 2022.3+ plugin that exposes 784 editor‑automation “Skills” as REST endpoints. AI agents (Claude Code, Antigravity, Codex, Cursor, OpenCode, etc.) can call these endpoints to create, modify, or delete scenes, assets, and meta files. The system includes a three‑tier permission model, dry‑run previews, structured JSONL audit logs, and per‑task rollback, plus transactional batch calls with automatic rollback on failure.

  • Project
    1mancompany/OneManCompany

    An agentic operating system that lets a single human act as CEO of a virtual company staffed by collaborating AI employees to deliver professional-grade products.

  • Project
    jnMetaCode/agency-orchestrator

    Agency Orchestrator is a Node‑JS tool that lets you run dozens of AI “expert” roles together. You can write a short YAML workflow or simply give a one‑sentence prompt; AO picks the right roles, builds a DAG, calls LLM providers (Claude, DeepSeek, OpenAI, etc.), runs steps in parallel, and produces a final report. It includes a web Studio UI, role libraries (267 Chinese roles + multilingual packs), support for key‑less providers, acceptance criteria, resumable runs, and integrations with coding assistants via an MCP server.