HEYM

MCP开发工具

提供方 heymrun

开发工具 SSE · 服务端推送 API Key 社区 / 第三方 Claude DesktopClaudeCursorVS Code

Self-hosted AI workflow automation platform with visual canvas, agents, RAG, HITL, MCP, and observability in one runtime. Expose your Heym workflows as an MCP server at /api/mcp/sse — callable from Claude Desktop, Cursor, or any MCP client.

一句话选型结论

按资料字段整理

HEYM 属于开发工具类 MCP 服务器,SSE · 服务端推送,API Key,可直接接入 Claude Desktop、Claude、Cursor 等,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类开发工具 传输方式SSE · 服务端推送 鉴权API Key 部署方式远程部署
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

开发工具
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

mcp automation ai agents workflows self hosted rag mcp server workflow automation

支持客户端

适用场景

mcpautomationai agents

安装与配置

SSE · 服务端推送 API Key
早期远程传输方式,正在被 HTTP 取代
  1. 1
    准备运行环境

    确认你的客户端支持远程端点,并拿到服务地址。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
代码与仓库操作

在对话里直接查代码、提 issue、走 PR,省掉来回切工具。

本地命令与脚本

把构建、测试、格式化这类重复命令交给模型执行。

接口联调与测试

让模型调你的接口、跑一遍用例,快速定位问题。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 已适配 Claude Desktop、Claude、Cursor,换客户端不用重新研究配置。

先想清楚的地方

  • 远程端点依赖网络与服务方可用性,注意密钥与调用额度。
  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 使用前要准备好API Key对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在开发工具场景里让模型直接调用外部能力的人。
  • 已经在用 Claude Desktop、Claude 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
HEYM当前 未标注 SSE · 服务端推送 远程部署 无 未标注
Git 838e2ec1 12 stdio · 本地进程 本地部署 有 2026-05-17
Markitdown MCP 2c653a5f 1 stdio · 本地进程 本地部署 有 2026-05-17
JavaGuide 未标注 stdio · 本地进程 本地部署 有 2026-04-11
awesome-claude-skills 未标注 stdio · 本地进程 本地部署 有 2026-04-26
Context7 831acf40 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

开发工具
字段来自项目仓库与公开索引,中文说明由本站标注
提供方heymrun上游标注的维护方 heymrun
分类开发工具本站按上游分类展示
连接方式SSE · 服务端推送早期远程传输方式,正在被 HTTP 取代
鉴权方式API Key远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · Cross-platform本地安装时用到的包标识与运行时
部署类型远程部署上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

36.7 KB
来自项目仓库与上游目录的原文,未做删改

Heym

Build agentic systems. Run them with confidence.

Heym is a self-hosted runtime and platform for building, orchestrating, running, observing, evaluating, and controlling agentic systems on your infrastructure.

Visually compose agents and deterministic workflows, or generate them with AI. Connect models, tools, MCP, company knowledge, and internal systems, then operate them with approval checkpoints, retries, and visibility into execution and model costs.

heym.run

Try locally: git clone https://github.com/heymrun/heym.git && cd heym && ./run.sh

Quick Start ·
Deploy & Call Workflows ·
Extending Heym ·
Security


What Is Heym?

In Heym, a workflow defines how agents, deterministic steps, tools, and data work together. The runtime executes that graph, coordinates dependent and parallel work, records execution history, and supports human review checkpoints.

The canvas is one interface into Heym. It is not Heym itself. Use it to build, inspect, debug, and understand systems running on the runtime. Those same workflows also run through APIs, schedules, event triggers, MCP clients, and Portal conversations.

Explore the product site at heym.run.

One Runtime for the Agent Lifecycle

Build → Orchestrate → Run → Observe → Evaluate → Control → Expose

These are connected parts of operating an agentic system in Heym.

Stage What you do in Heym
Build Compose agents and deterministic workflows visually, generate them with AI, or start from reusable templates and skills.
Orchestrate Coordinate agents, sub-agents, sub-workflows, and tools with explicit data flow, branching, and parallel execution where dependencies allow.
Run Execute from APIs, schedules, event triggers, or interactive interfaces, with configurable retries, error paths, and browser automation.
Observe Inspect execution history, live state, traces, tool calls, tokens, latency, errors, and model costs. Review analytics and alerts, and export OpenTelemetry traces.
Evaluate Test prompts and model responses against expected outputs, compare results across models, and inspect saved evaluation runs.
Control Pause Agent execution at review checkpoints and resume from saved state after a human decision. Configure guardrails, credentials, authentication, and team access.
Expose Serve workflows through REST, SSE streaming, MCP tools, and Portal chat interfaces, or connect their results to in-app dashboard widgets.

Use observations and evaluation results to refine prompts, tools, and workflow logic, then run and inspect the next iteration.

🗺️ Platform Overview

The workflow definition connects the build experience to execution. The runtime uses that definition to coordinate nodes and tools, while execution state feeds the interfaces people use to inspect, review, and consume the results.

Part of the system How it fits
Build and inspect The canvas, AI Assistant, templates, and Expression DSL create and edit workflow definitions. The same canvas can attach to an active execution for inspection.
Orchestrate and execute The executor coordinates agents, deterministic nodes, sub-workflows, parallel branches, retries, and review checkpoints.
Connect tools and data Nodes and agent tools reach models, HTTP APIs, MCP servers, internal knowledge, persistent memory, databases, queues, and files.
Operate and improve History, traces, costs, analytics, alerts, logs, and OpenTelemetry reveal runtime behavior. Evals support prompt and model iteration; access controls and human review shape how systems run.
Serve people and applications REST and SSE endpoints, MCP tools, Portal conversations, Board jobs, and workflow-backed dashboards provide ways to invoke systems and use their results.

✨ Key Capabilities

Build: Agents, Workflows, and Connected Tools

  • Visual and AI-assisted authoring. Build and inspect workflow graphs on the canvas, generate or revise them through the AI Assistant using text or voice, and reuse templates.
  • Agents and deterministic logic. Combine LLM and Agent nodes with conditions, switches, loops, merges, data transformations, and sub-workflow calls. Use expressions in supported node fields.
  • Multi-agent orchestration. Give an orchestrator named sub-agents and sub-workflows to call. Independent sub-agent calls can execute concurrently.
  • Knowledge and persistent memory. Retrieve documents through RAG using Qdrant or PostgreSQL with pgvector. Enable per-agent knowledge graphs to retain facts across runs, with configurable sharing between agents.
  • Tools and integrations. Connect communication services, developer tools, productivity apps, databases, queues, and storage through built-in nodes, HTTP APIs, and MCP. Use MCP Call nodes for deterministic tool invocation.
  • Skills and custom behavior. Attach reusable SKILL.md instructions and optional Python tools to agents, create or revise skills with AI, install plugins, or implement custom nodes with typed configuration and execution handlers.

Run: Execute and Coordinate Work

  • Parallel execution and recovery. Run independent nodes concurrently, synchronize branches with Merge, and configure retries, backoff, error paths, and model fallback.
  • Schedules and triggers. Start workflows through cron, webhooks, messaging integrations, inbox events, WebSocket messages, and Heym platform events.
  • Browser and coding agents. Automate browser tasks with Playwright and AI-assisted selector recovery. Run Codex or OpenCode Go against a repository as workflow steps, with diff and pull-request outputs.
  • Agentic Kanban Board. Cards are persistent agentic jobs. Moving a card into a column runs its ordered workflow chain with card content, comments, history, and previous outputs, then writes results back to the card.
  • Load distribution. Share eligible background runs across Heym instances through PostgreSQL, with execution weights configured in Settings → Instances.

Observe: Understand Execution and Cost

  • History and live execution. Open a production run from History or a Board card, inspect its saved state, and follow live node progress, Debug logs, and final output.
  • Traces and model costs. Inspect model requests, responses, tool calls, input/output tokens, latency, and errors. Calculate USD costs with maintained model pricing and custom overrides, and explore historical spending by model and time range.
  • Analytics, logs, and alerts. Track execution volume, success rates, and duration; review logs; set alerts for errors, duration, token or USD spend, and run count. Export workflow, node, and Agent tool spans through OpenTelemetry.

Evaluate & Control: Improve Behavior and Keep Humans Involved

  • Evals and analysis. Run repeatable prompt evaluations across models, compare expected and actual outputs, and review historical results. The Workflow Analyzer uses execution context to create a shared, editable Markdown report on purpose, step behavior, and improvement areas.
  • Human review. Agent checkpoints pause execution for acceptance, edits, or refusal, then continue from a saved execution snapshot. A review branch can notify people through existing integrations.
  • Security and access. Configure input guardrails, encrypted credentials, team sharing, execution tokens, and workflow authentication. Sign in with JWT authentication or OIDC SSO through providers such as Keycloak, Okta, Entra ID, Auth0, and Google.

Expose: Put Systems to Work

  • REST, SSE, and MCP. Invoke workflows from applications, stream execution events, or publish workflows as tools for MCP clients.
  • Portal and Chat. Publish workflow-backed chat interfaces with streaming, uploads, and conversation history. Use the Chat tab to call workflows and work with models and platform data.
  • Dashboards, data, and files. Build custom dashboard widgets backed by workflows, manage structured Data Tables, and keep generated files in Heym Drive with team sharing and share links.

🎬 Product Tour

One e-commerce sales campaign, followed end to end: workflow generation with the AI Assistant, human review, board execution, structured data, dashboards, traces, RAG, MCP, analytics, and team collaboration.

Product Demos

The demos follow an orchestrator and sub-agent system from creation to a chat interface. For a request such as “How do I get from Berlin to Frankfurt?” and “What should I eat there?”, the orchestrator can call independent sub-agents in the same turn, run those tasks concurrently, and combine their results.

Generate Workflows from Natural Language

Describe the agents, orchestration pattern, and user-facing result you want; Heym builds the workflow on the canvas.

Example prompt

> Create a workflow for me that includes a Roadmap Agent and a Best Food Agent. When the Orchestrator Agent receives a request, it will invoke these subagents in parallel and return the result to the user.

Run and Inspect a System

Start a runtime execution from the canvas and inspect each step as results move through the graph. APIs, schedules, triggers, and MCP can invoke the same workflow.

Create Skills for Agents

Create agent skills from natural language, preview the generated SKILL.md, and attach them to the agent.

Example prompt

> Create a skill for me and add it to the agent. The Orchestrator Agent will call this skill after receiving information from the subagents, and the skill will create a simple execution plan explaining what can actually be done in the destination city.

Call Workflows from Chat

Turn a workflow into a chat experience so users can invoke the orchestration with a natural request.

Example prompt

> I live in Berlin and am planning to go to Frankfurt. How many kilometers is it on the Autobahn? Also, where can I find the best doner in Frankfurt?

📸 Screenshots

Visual Canvas: Multi-agent orchestration, RAG and MCP nodes, human-in-the-loop checkpoints

MCP Server: Publish workflows as tools for Claude, ChatGPT, or Cursor

Traces: Inspect model requests, responses, tokens, latency, and cost

Analytics: Execution volume, success rate, latency, and time saved per workflow

Watch Heym Tutorials


🚀 Quick Start

Prefer to watch it first? Set Up Heym Locally in Under 2 Minutes walks the whole path: clone the repository, start PostgreSQL and create your account on a local instance.```bash
git clone https://github.com/heymrun/heym.git
cd heym
./run.sh

OR: with .env file (run.sh auto-generates SECRET_KEY and ENCRYPTION_KEY)

git clone https://github.com/heymrun/heym.git
cd heym
cp .env.example .env
./run.sh


Open **http://localhost:4017** to create your account and start building. `run.sh` starts PostgreSQL, the backend, and the frontend, and generates `SECRET_KEY` and `ENCRYPTION_KEY` when needed.

**Prerequisites:** Bun, Python 3.11+, UV, and Docker. For containers, use the deployment options below. See ENVIRONMENT-VARIABLES.md for every setting and its default.

---

## Deployment

Heym runs on your infrastructure with **PostgreSQL as its core database**. The standard Compose setup includes PostgreSQL, the backend, and the frontend, with local volumes for persistent files. RabbitMQ and Redis are integrations you connect when a workflow needs them. RAG can use the built-in PostgreSQL/pgvector backend or an external Qdrant server; S3 is available through its integration node.

### Docker Compose

Use Docker Compose and Python 3 for production deployment:```bash
cp .env.example .env
./deploy.sh              # Build and deploy (auto-generates keys if empty)
./deploy.sh --down       # Stop services
./deploy.sh --logs       # View logs
./deploy.sh --restart    # Restart services

> Register your admin account first, then set ALLOW_REGISTER=false in .env and restart to close registration in production.

Prebuilt Docker Image

The release image bundles the frontend and backend. The examples below connect it to an existing PostgreSQL database on the host; set DATABASE_URL to your database address and credentials. On Linux, add --add-host=host.docker.internal:host-gateway when using that hostname.

Docker commands with persistent files, plugins, and coding-agent workspaces```bash

Docker with .env file

git clone https://github.com/heymrun/heym.git
cd heym
cp .env.example .env

Generate required keys and write them into the placeholder lines copied from

.env.example (replace in place: appending with >> would create duplicate entries):

SECRET_KEY=$(python3 -c "import secrets; print(secrets.token_urlsafe(32))")
ENCRYPTION_KEY=$(python3 -c "import secrets; print(secrets.token_hex(32))")
sed -i.bak "s|^SECRET_KEY=.|SECRET_KEY=${SECRET_KEY}|; s|^ENCRYPTION_KEY=.|ENCRYPTION_KEY=${ENCRYPTION_KEY}|" .env && rm -f .env.bak
docker run --env-file .env \
-e DATABASE_URL=postgresql+asyncpg://postgres:postgres@host.docker.internal:6543/heym \
-p 4017:4017 \
--shm-size 2g \
-e FILE_STORAGE_DIR=/app/data/files \
-e HEYM_PLUGINS_DIR=/app/data/plugins \
-v /var/run/docker.sock:/var/run/docker.sock \
-v "$(pwd)/data/files:/app/data/files" \
-v "$(pwd)/data/plugins:/app/data/plugins" \
-v heym-codex-workspaces:/app/data/codex-workspaces \
-v heym-opencode-workspaces:/app/data/opencode-workspaces \
ghcr.io/heymrun/heym:latest

OR: minimal, no .env file

docker run \
-e ENCRYPTION_KEY=$(python3 -c "import secrets; print(secrets.token_hex(32))") \
-e SECRET_KEY=$(python3 -c "import secrets; print(secrets.token_hex(32))") \
-e DATABASE_URL=postgresql+asyncpg://postgres:postgres@host.docker.internal:6543/heym \
-e FILE_STORAGE_DIR=/app/data/files \
-e HEYM_PLUGINS_DIR=/app/data/plugins \
-p 4017:4017 \
--shm-size 2g \
-v /var/run/docker.sock:/var/run/docker.sock \
-v "$(pwd)/data/files:/app/data/files" \
-v "$(pwd)/data/plugins:/app/data/plugins" \
-v heym-codex-workspaces:/app/data/codex-workspaces \
-v heym-opencode-workspaces:/app/data/opencode-workspaces \
ghcr.io/heymrun/heym:latest


The mounts and runtime settings support these capabilities:

- **Playwright:** `--shm-size 2g` gives Chromium room for browser tasks. Step-based Playwright runs inside the Heym container; custom `playwrightCode` uses a sibling container with its own shared-memory setting. Compose configures this for you.
- **Heym Drive:** `FILE_STORAGE_DIR=/app/data/files` points file storage at the mounted directory, keeping uploads and generated files across container restarts.
- **Plugins:** `HEYM_PLUGINS_DIR=/app/data/plugins` and its mount preserve installed plugin packages.
- **Skills and Codex:** the `heym-codex-workspaces` volume connects the runtime to its hardened sibling containers. Per-run isolation uses Docker Engine 25.0+.
- **OpenCode Go:** the `heym-opencode-workspaces` volume preserves the workspace shared with its sibling runner.
- **Docker access:** the socket supports sandbox containers and MCP `stdio` execution. It grants broad host control, so restrict access to your deployment. Docker log access is configured separately with `DOCKER_LOGS_ENABLED` and `DOCKER_LOGS_ALLOWED_EMAILS`; create allow-listed accounts before opening registration.

### Multi-Instance Execution

Connect additional Heym instances to the same PostgreSQL database to distribute eligible background workflow runs. Configure their shares from **Settings → Instances**. PostgreSQL carries the queue and coordination, so the cluster needs no separate message broker or direct instance-to-instance connection.

The main instance serves the UI, API, MCP, and Portal and owns local files and installed plugins. Workers execute eligible queued runs; workflows that depend on main's local storage or workspaces run there. The Load Distribution guide covers placement, shared keys, database sizing, ingress, and upgrades, with cluster and worker Compose examples.

Heym is in its pre-1.0 release series. Follow the version badge and releases for updates. The deployment guide and security policy provide the operational setup reference.

---

## Extending Heym

Connect Heym to the systems your team already uses. Choose built-in integrations, HTTP APIs, MCP, reusable skills, plugins, or custom nodes to bring tools and data into the runtime.

| Extension path | Best for | How it works |
|----------------|----------|--------------|
| HTTP APIs | APIs and internal services | Configure requests, headers, authentication, and expressions with the HTTP node. |
| Plugins | Installable node types and triggers | Add operator-installed packages with runtime handlers and editor schemas. See Plugin Authoring. |
| Custom nodes | Product-grade workflow steps and integrations | Add a typed node with editor configuration, execution behavior, and schema metadata. |
| Agent skills | Portable agent abilities | Attach a `SKILL.md` file and optional Python tools to Agent nodes, or generate them with AI Build. |
| MCP | External tools and AI clients | Agent nodes consume MCP servers, and Heym workflows can be exposed as MCP tools. |
| Workflow as tool | Reusable automations | Call workflows through REST, SSE, Portal chat, or MCP without duplicating the logic. |

### Built-In Integrations and Node Library

| Purpose | Representative nodes and connections |
|---------|-------------------------------------|
| **Communication** | Slack, Discord, Telegram, and SMTP/IMAP email for mail services such as Gmail and Outlook |
| **Developer tools and productivity** | GitHub, Jira, Linear, Notion, Google Drive, Google Sheets, Grist, and Sentry |
| **Data, queues, and storage** | BigQuery, ClickHouse, Supabase, Redis, RabbitMQ, Amazon S3, Heym Data Tables, and Drive |
| **Knowledge** | RAG with Qdrant or PostgreSQL/pgvector, plus per-agent persistent memory |
| **APIs and browsers** | HTTP, WebSocket Trigger/Send, MCP Call, Crawler, and Playwright |

The node library brings agents together with deterministic logic, triggers, data, and outputs:

| Category | Nodes |
|----------|-------|
| **Triggers** | Input (Webhook), Cron, Slack, Discord, Telegram, IMAP, WebSocket, File Upload, Heym events, RabbitMQ Receive, Plugin Trigger |
| **AI** | LLM, Agent, RAG, Codex, OpenCode Go |
| **Logic** | Condition, Switch, Loop, Merge |
| **Data** | Set, Variable, DataTable, Execute (sub-workflow), Converter |
| **Output and utilities** | Output, Chart Output, JSON/HTML Output Mapper, Wait, Console Log, Error Handler, Throw Error, Disable Node, Enable Node, Sticky Note |

Heym Drive stores uploaded and generated files with public or password-protected share links, team sharing, and bulk ZIP, share, and delete actions. See Drive.

See the node reference and integration guides for operations, credentials, and setup.

### MCP (Model Context Protocol)

**As a client:** Agent nodes discover and call tools from configured MCP servers over SSE, Streamable HTTP, or `stdio`. The MCP Call node invokes a selected tool directly when the workflow defines the call.

**As a server:** Publish Heym workflows as tools at `/api/mcp/sse` for Claude Desktop, Cursor, and other MCP clients. See MCP configuration.

### Skills System

Skills are portable capability bundles: a `SKILL.md` instruction file plus optional Python tools and assets. Drop a `.zip` or `.md` onto an Agent node, or use **AI Build** to draft and iterate on skills from chat. Reuse and share them across workflows and teams.

---

## Build and Orchestrate

### Real-time Collaboration

Open the same workflow with your team and work on it together. Everyone on the canvas shows as an avatar at the top left, pointers move in each person's color, and edits reach every open canvas as they happen. Click an avatar to follow what that person sees, including the dialogs they open and the runs they start, and turn on the microphone to talk directly from the browser.

### AI Assistant

Describe the system you want in plain text or voice. The assistant generates nodes and edges directly in the editor, where you can inspect and refine the resulting workflow.

When a workflow already contains Agent skills, the assistant sends only each skill's `SKILL.md` into the builder context. Large `.py` files and binary attachments stay out of the prompt so workflow editing remains reliable even with complex skills loaded on the canvas.

### AI Skill Builder

Inside the Agent node's Skills section, use **AI Build** to create a new skill or the inline sparkle action to revise an existing one. The modal streams a chat conversation, previews generated `SKILL.md` and `.py` files live, and saves them back through the same ZIP ingestion path used by manual skill uploads.

### Multi-Agent Orchestration

Build orchestrator/sub-agent pipelines visually. One agent delegates tasks to named sub-agents or sub-workflows, composing their results into a shared response. Configure reasoning effort and temperature per agent.

### Built-In RAG Pipeline

Upload PDFs, Markdown, CSV, or JSON to a managed vector store backed by Qdrant or PostgreSQL/pgvector. Wire a RAG node into a workflow for semantic search, with retrieved context flowing into an LLM or Agent node.```
Input → RAG (search) → LLM (answer with context) → Output

Persistent Memory

Enable a knowledge graph for an Agent node to retain entities and relationships across runs. Heym adds graph context to the agent's prompt and merges new facts in the background after successful runs. Use the graph editor to inspect and edit memory or grant other agents read or read/write access. See Agent Persistent Memory.

LLM Configuration and Batch Processing

Configure reasoning effort, temperature, and fallback models for Agent execution. LLM nodes support text, vision, structured output, and provider-native Batch API mode for supported endpoints, with live status branches and per-item results. Agent message history is automatically compressed as it approaches the model context limit, with compression events visible in Debug logs, History, and Traces. See the LLM node and Agent node references.


Execution Behavior

Parallel Execution

Independent nodes run concurrently based on graph dependencies. Use the Merge node to synchronize parallel branches and combine their results. The graph defines the execution order. See Parallel Execution.

Browser Automation and Auto Heal

Playwright nodes support visual steps, AI-generated actions, and full-code browser automation. Enable Auto Heal to use page context for selector recovery when an action fails. See the Playwright node reference for configuration.

Node-Level Error Handling

Configure retry on failure and error branching on nodes:```
Input ──→ HTTP ──→ Output
└─── error ──→ Error Handler


- **Retry**: automatically re-run a failed node with configurable attempts and backoff
- **Error branch**: route failures to a dedicated path instead of stopping the workflow
- **Error context**: access `$nodeName.error` in downstream nodes

---

## 🔍 Observability, Evaluations, and Control

### Execution History and Live State

Inspect saved inputs, outputs, node results, errors, timing, and execution logs. History connects a run to its trigger and, in a cluster, the instance that executed it.

### Open any production run live

Open a **Running** entry from either History dialog or the run list inside a Board card, and Heym attaches the editor to that exact execution over SSE. This works for runs started by webhooks, schedules, chat, MCP, integrations, or the Agentic Kanban Board. Completed
nodes are restored immediately; the current and pending nodes keep pulsing; Debug logs and the
final output arrive incrementally. Leaving the editor disconnects only the observer and never
cancels the production run.

### LLM Traces

Inspect model requests and responses, tool-call details, per-call timing, token usage, errors, and skills passed to the model. Use traces alongside workflow history to follow the relationship between model behavior and the surrounding execution. See Traces.

### Model Usage and Cost Visibility

Heym records **input and output tokens** and calculates **USD costs** from maintained model pricing data. Inspect costs per trace and explore historical usage and spending by model and time range. Add **custom model pricing overrides** for your own endpoints or rates.

Cost visibility also connects to operations: alerts can evaluate token or USD spend over a chosen time window. See Traces and cost analytics for pricing and usage views.

### Analytics and Logs

Review execution volume, success rates, latency, and estimated time saved by workflow in Analytics. Follow incremental Debug logs while inspecting a run, and enable access-controlled Docker log viewing and streaming through the Logs tab.

### Alerts

Set thresholds over a **time window** on four metrics: error count, run duration (max, average, or p95), LLM token or USD spend, and execution count. Scope an alert to one workflow or all workflows you can access.

A five-step wizard covers type, scope, condition, response, and review. Describe the rule in natural language to fill the form with AI, then preview the condition against historical windows before saving. By default, an alert fires once and waits for the metric to recover before firing again.

An alert can run a workflow with the observed value, threshold, window, and contributing detail as input. Use existing Slack, email, or Telegram nodes to deliver notifications. The Chat tab can explain which alerts exist and why one triggered. See Alerts.

### Evals: Test, Compare, Improve

Create suites with a system prompt, test inputs, and expected outputs. Run the same cases across multiple models and repeat runs to compare responses. Inspect scores, actual versus expected output, latency, token usage, and saved run history.

Use evaluation results to guide prompt changes, generate additional test data, or request an AI-assisted prompt revision. Pair those results with execution traces and Workflow Analyzer reports to improve the system you operate. See Evals and Workflow Analysis.

### Human-in-the-Loop (HITL)

Agent review checkpoints turn human approval into part of execution. When an agent requests review, Heym saves an execution snapshot and marks the run as pending. The agent's `review` branch can send the review link and summary to Slack, email, or another notification flow.

A reviewer can **Accept**, **Edit & Continue**, or **Refuse**. Heym resumes from the saved snapshot with the decision and reviewed text available to downstream nodes. An agent can request further checkpoints during the same run. See Human-in-the-Loop.

### Guardrails and Access Controls

Configure category-based and multilingual guardrails on LLM and Agent input messages. Checks run before the model call and route violations through the workflow's error-handling paths.

### OpenTelemetry Tracing

Export a root span per workflow run, a child span per node, and Agent tool spans (`heym.agent.tool.execute`) over OTLP/HTTP to Jaeger, Grafana Tempo, Honeycomb, Datadog, or any OpenTelemetry backend. Spans carry workflow id, node type, status, duration, LLM token usage, and tool identity/status, with W3C trace context propagated across inbound webhooks, outbound HTTP, and sub-workflows. Enable tracing with the `HEYM_OTEL_*` environment variables and review status under **Settings → Observability**. See OpenTelemetry Tracing for configuration and span details.

---

## Deploy & Call Workflows

The same runtime can serve people, backend services, and external agents. Choose an interface for how the system will be used:

| Interface | Endpoint or surface | Use |
|-----------|---------------------|-----|
| **REST** | `POST /api/workflows/{workflow_id}/execute` | Invoke a workflow from an application or HTTP webhook. |
| **SSE** | `POST /api/workflows/{workflow_id}/execute/stream` | Stream execution progress and node events to a client. |
| **MCP server** | `/api/mcp/sse` | Publish workflows as tools for MCP clients. |
| **Portal** | `/chat/{slug}` | Provide a workflow-backed chat interface for people. |
| **Dashboard** | Dashboard tab | Run workflow-backed widgets to produce charts and operational views. |
| **Board** | Board tab | Run workflow chains as persistent jobs with card context and history. |
| **Schedules and events** | Cron and integration triggers | Execute in response to time, messages, uploads, or platform events. |

The editor's **Run with cURL** dialog generates commands for REST or SSE, including per-node start messages and live event output. See Webhooks and SSE Streaming for authentication, request bodies, and event formats.

### Portal

Turn a workflow into a public chat interface at `/chat/{slug}` with optional per-user authentication, streaming responses, file uploads, and multi-turn conversation history. Build internal tools and customer-facing chat interfaces directly from your workflow. See Portal.

### Workflow-Powered Dashboards

Each custom dashboard widget is backed by its own hidden Heym workflow. Fetch, transform, retrieve, or generate data through workflow logic and display the result as a chart in the dashboard. See Dashboard.

---

## 📝 Expression DSL

Reference and transform data between nodes with a clean syntax:```js
$input.text                         // Trigger input
$nodeName.field                     // Any upstream node output
$global.variableName                // Persistent global variable
$now.format("YYYY-MM-DD HH:mm")    // Date/time formatting
$UUID                               // Random unique ID
$range(1, 10)                       // Generate number range
$input.items.filter("item.active")  // Array filtering

…(正文过长,页面只展示前面部分,完整内容见仓库)

常见问题

8 问
答案由本站依据条目字段整理,不引用上游原文
HEYM 怎么安装?

资料没有给出安装命令,请到官方仓库或文档按说明接入;这类条目多数是生态应用,或尚未发布可安装包。

HEYM 怎么在 Claude Desktop、Claude、Cursor 里配置?

它的传输方式是SSE · 服务端推送,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

HEYM 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

HEYM 需要 API Key 吗?

资料标注需要API Key认证,使用前准备好对应凭据,并按最小权限配置。

HEYM 支持哪些客户端?

资料标注支持 Claude Desktop、Claude、Cursor、VS Code、Windsurf、Codex;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

HEYM 能提供哪些能力?

资料显示能力标签包括 mcp、automation、ai agents、workflows、self hosted、rag。具体工具清单以官方文档为准。

HEYM 需要什么运行环境?

运行时为 Cross-platform;属于远程端点,不需要在本地装运行时。

HEYM 是本地还是远程?

它是远程端点,连服务地址即可。传输方式为SSE · 服务端推送。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 未标注。