Skillget

UnifAI

mcp
SUMMARY

Production-grade multi-agent orchestration engine. Compose agentic workflows from a pluggable catalog of Agents, LLMs, tools, and retrievers. Execute locally with LangGraph or distributed with Temporal. Built-in RAG pipeline for enterprise knowledge retrieval. A2A and MCP protocol support. Visual drag-and-drop blueprint builder.

README.md

UnifAI

A platform for building and running multi-agent AI workflows over your enterprise knowledge.

UnifAI lets you connect internal data sources — Slack, Jira, documents — into a unified vector store, then query them through composable, visual multi-agent pipelines. Define agent graphs as YAML blueprints or build them with a drag-and-drop UI, execute locally or at scale, and stream results in real time.

What It Does

Most teams have knowledge scattered across Slack threads, Jira tickets, PDFs, and internal wikis. Finding answers means manually digging through multiple systems. UnifAI fixes this:

  1. Compose — Build multi-agent workflows that reason across sources, route conditionally, and combine results
  2. Execute — Run workflows locally or distributed, with real-time streaming
  3. Interact — Use the web UI to build blueprints visually, trigger executions, and inspect every node's input/output
  4. Ingest — Pull content from Slack, documents (PDF, Markdown), and more into a vector database for agents to search

Architecture

┌───────────────────────────────────────────────────────────────┐
│                     React / Vite / Tailwind UI                │
│                                                               │
│   ┌─────────────────────┐    ┌──────────────────────────┐     │
│   │   RAG Dashboard     │    │   Blueprint Builder &    │     │
│   │   Data source stats │    │   Agent Chat Interface   │     │
│   └─────────────────────┘    └──────────────────────────┘     │
└──────────┬───────────────────────────────┬────────────────────┘
           │ /api1                         │ /api2
           ▼                               ▼
  ┌─────────────────┐          ┌──────────────────────────┐
  │   RAG Backend   │◄────────►│  Multi-Agent Backend     │
  │                 │  search  │                          │
  │ • Ingestion     │          │ • Blueprint engine       │
  │ • Chunking      │          │ • Agent orchestration    │
  │ • Embedding     │          │ • LangGraph / Temporal   │
  │ • Vector search │          │ • Real-time streaming    │
  │ • Celery workers│          │ • A2A & MCP protocols    │
  └────────┬────────┘          └─────────────┬────────────┘
           │                                 │
           ▼                                 ▼
┌───────────────────────────────────────────────────────────────┐
│                    Shared Infrastructure                       │
│     MongoDB · Qdrant · RabbitMQ · Redis (opt) · Temporal      │
└───────────────────────────────────────────────────────────────┘

Multi-Agent System — The Core

The heart of UnifAI is its Multi-Agent System (MAS): a production-grade orchestration engine for defining, executing, and streaming multi-agent workflows.

Blueprint-Driven Workflows

Agents are composed into directed graphs called blueprints. Each blueprint declares nodes, edges, conditions, and the tools/LLMs each agent can use — all in a single YAML file:

name: "Multi-Source Knowledge Search"

llms:
  - rid: llm_rid
    type: openai
    config:
      model_name: gpt-4o
      base_url: https://api.openai.com/v1

retrievers:
  - rid: docs_retriever_rid
    type: docs_rag
    config: { top_k_results: 5 }
  - rid: slack_retriever_rid
    type: slack
    config: { top_k_results: 5 }

nodes:
  - rid: input_rid
    type: user_question_node
  - rid: docs_agent_rid
    type: custom_agent_node
    config:
      llm: llm_rid
      retriever: docs_retriever_rid
      system_message: "Search internal documentation..."
  - rid: slack_agent_rid
    type: custom_agent_node
    config:
      llm: llm_rid
      retriever: slack_retriever_rid
      system_message: "Search Slack messages..."
  - rid: merger_rid
    type: merger_node
  - rid: answer_rid
    type: final_answer_node

plan:
  - uid: input
    node: input_rid
  - uid: docs
    after: input
    node: docs_agent_rid
  - uid: slack
    after: input
    node: slack_agent_rid
  - uid: merge
    after: [docs, slack]
    node: merger_rid
  - uid: answer
    after: merge
    node: answer_rid

Blueprints can be pre-defined in YAML or built visually through the UI's drag-and-drop editor.

Element Catalog

Blueprints are composed from a rich catalog of pluggable elements:

Category Available Types Description
Nodes custom_agent_node, orchestrator_node, merger_node, a2a_agent_node, branch_chooser_node, user_question_node, final_answer_node The building blocks of agent graphs
LLMs openai, google_genai LLM providers (any OpenAI-compatible API)
Tools ssh_exec, web_fetch, oc_exec, mcp_proxy Actions agents can perform
Providers mcp_server, a2a_agent, rag_client External service integrations
Retrievers docs_rag, slack RAG-powered context retrieval
Conditions router_direct, router_boolean, threshold Conditional edge routing

The catalog is extensible — new elements are auto-discovered at startup.

Execution Modes

Mode Engine Best For
Local LangGraph Development, single-process execution
Distributed Temporal Production, horizontal scaling across workers

Both modes use the same blueprint format. Switch between them with a single environment variable.

Real-Time Streaming

Executions stream node-by-node output as NDJSON over HTTP, so clients can render progress as it happens. Two patterns are supported:

  • Synchronous streaming — execute and stream results in a single request
  • Fire-and-forget — submit a workflow, then subscribe to its event stream from any client

Protocol Support

  • A2A (Agent-to-Agent) — Delegate tasks to remote agents over the A2A protocol. Any A2A-compatible agent can be added as a node in a blueprint.
  • MCP (Model Context Protocol) — Connect to MCP servers to give agents access to external tools (Jira, GitHub, databases, etc.). Configure once as a provider, then attach to any agent node.

Templates

Pre-built workflow templates with placeholders let users instantiate complex blueprints without writing YAML — browse templates in the UI, fill in the blanks, and start executing.

Web UI

A React-based interface with two primary views:

Blueprint Builder — Visual drag-and-drop editor for composing agent graphs. Select nodes from the element catalog, wire them together, configure LLMs and tools, then execute — all without writing YAML. During execution, inspect each node's input/output in real time.

RAG Dashboard — Monitor data source health: document counts, chunking/embedding status, last ingestion timestamps. Upload documents and register Slack channels.

RAG Pipeline

The RAG module feeds the multi-agent system with indexed enterprise knowledge:

  • Sources — PDF, Markdown documents, Slack channels and threads
  • Processing — Intelligent chunking, metadata extraction, async background workers
  • Storage — Vector embeddings in Qdrant, metadata in MongoDB
  • Search — Semantic similarity search exposed to agents via retriever elements
  • Flexibility — Document conversion and embedding services can run locally or as remote microservices, toggled via feature flags

Tech Stack

Layer Technologies
Multi-Agent Backend Python 3.11+, Flask, LangGraph, Temporal, Redis
RAG Backend Python 3.11+, Flask, Celery, Qdrant, RabbitMQ
Frontend React 18, TypeScript, Vite, Tailwind CSS, Radix UI
Auth Keycloak (OAuth 2.0 / OIDC)
Storage MongoDB, Qdrant (vectors), Redis (streams)
Deployment Helm, Helmfile, OpenShift / Kubernetes, Docker

Quick Start

Prerequisites

  • Python 3.11+
  • Node.js 22+ and PNPM
  • MongoDB
  • Qdrant

Optional: Redis (for distributed streaming), Temporal (for distributed execution), RabbitMQ (for async RAG pipelines), Keycloak (for auth).

Multi-Agent Backend

cd multi-agent
pip install -e ".[all]"

# Configure
export ENGINE_NAME=langgraph
export MONGODB_IP=localhost

# Run
mas api --dev

RAG Backend

cd rag
pip install -r requirements.txt

# Run Flask server
python -m flask run --port 8001

# Run Celery workers (separate terminal)
celery -A app.celery worker

UI

cd ui
pnpm install --frozen-lockfile
pnpm dev

The UI runs at http://localhost:5173 and proxies API requests to the backends.

Deployment

For Kubernetes/OpenShift deployment, see the Helm Deployment Guide.

Project Structure

unifai/
├── multi-agent/          # Multi-Agent System — orchestration engine
│   └── lib/mas/
│       ├── elements/     # Nodes, tools, LLMs, providers, conditions
│       ├── engine/       # LangGraph & Temporal execution engines
│       ├── blueprints/   # Blueprint resolution & validation
│       ├── sessions/     # Session lifecycle & streaming
│       ├── templates/    # Template instantiation
│       └── catalog/      # Element auto-discovery
├── rag/                  # RAG pipeline — ingestion, chunking, search
│   ├── core/             # Business logic & domain services
│   ├── infrastructure/   # Adapters (MongoDB, Qdrant, Celery)
│   └── bootstrap/        # Dependency injection & app setup
├── ui/                   # React frontend
├── shared-resources/     # SSO backend (Keycloak integration)
├── global_utils/         # Shared Python utilities
├── helm/                 # Helm charts & Helmfile for deployment
├── ci/                   # Jenkins CI/CD pipelines
└── tests/                # Test infrastructure

Documentation

Module README
Multi-Agent System multi-agent/README.md
RAG Pipeline rag/README.md
Web UI ui/README.md
Helm Deployment helm/README.md
SSO / Auth shared-resources/sso-backend/README.md
CI/CD ci/README.md

Contributing

Contributions are welcome! The system is designed to be modular — new agent nodes, tools, LLM providers, retrievers, and data source adapters can be added without modifying the core engine.

Reviews (0)

No results found