Elliot

MCP开发工具

提供方 EliBarak12

开发工具 未标注 会话登录 社区 / 第三方 ClaudeCursorCodexZed

Turn any API or database into agent-ready MCP tools — minimal tokens, structured errors, full observability.

一句话选型结论

按资料字段整理

Elliot 属于开发工具类 MCP 服务器,传输方式未标注,会话登录,可直接接入 Claude、Cursor、Codex 等,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类开发工具 传输方式未标注 鉴权会话登录 部署方式未标注
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

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

能力标签

支持客户端

适用场景

apidatabasesql

安装与配置

未标注 会话登录
上游未给出传输方式
  1. 1
    准备运行环境

    按官方文档确认运行环境(常见为 Node.js 或 Python),装好后再执行安装命令。

  2. 2
    安装服务

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

  3. 3
    写入客户端配置

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

  4. 4
    验证是否可用

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

典型使用场景

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

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

本地命令与脚本

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

接口联调与测试

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

选择建议

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

值得选的地方

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

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 使用前要准备好会话登录对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

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

不太适合

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

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Elliot当前 未标注 未标注 未标注 无 未标注
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

服务器档案

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

详细介绍

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

Elliot

Turn any API or database into MCP tools for Claude Code, Cursor, OpenClaw, and Codex — with built-in observability.

Documentation · Quickstart · Concepts · The five principles


Elliot is an open-source platform for turning the products you already have — REST APIs, SQL databases, files — into tools that AI agents can use well. Not just connected, but fast, safe, and observable: minimal token usage, structured errors the agent can recover from, and a full trace of every agent session.

The target user is a product engineer who has a working API or database today and wants AI agents to interact with it natively — with minimum tokens, clean error recovery, and full observability.

> AX is to agents what UX is to users and DX is to developers. Elliot's job is to make AX measurable.

Table of contents

  • Why Elliot
  • Features
  • Quickstart
  • See it in action
  • How it works
  • Connect your coding agent
  • Project layout
  • Documentation
  • Roadmap
  • Contributing
  • Community and support
  • License

Why Elliot

Connecting an API to an agent is easy. Making it work well is not. Agents fail when:

  • Tool descriptions are vague — the agent picks the wrong tool.
  • Results are too large — the context window fills up before the answer does.
  • Errors are unstructured — the agent cannot recover or escalate.
  • Nothing is observable — you do not find out it is broken until a user complains.

Elliot makes each of these visible and fixable. Every tool ships with a structured schema, a token estimate, an actionable error shape, and a session trace — every call, every agent, attributed to a client and model.

Features

  • Agent-ready by design — every tool is linted against five concrete principles before it ships: verb-first descriptions, typed parameters, context-sized results.
  • Safe by default — parameterised SQL, read-only database transactions, env-var secrets, no keys in connector files. Connector files are safe to commit.
  • Every call observable — tokens, latency, arguments, and errors for every agent call, streamed to an audit log and visible in Studio.
  • One command to run — start the whole stack with Docker. No Python, Node, or toolchain to install.
  • Works with every agent — Claude Code, Cursor, OpenClaw, and Codex. Elliot auto-registers with each.
  • Agents build connectors — discover, build, lint, eval, deploy. The platform itself is agentic: agents can build connectors through Elliot.

Quickstart

Just want to run Elliot? The only prerequisite is Docker — no Python, Node, uv, or pnpm:```bash
curl -LsSf https://raw.githubusercontent.com/EliBarak12/Elliot/main/scripts/install.sh | sh


This pulls the pre-built images, generates a local `.env`, starts all three services, and opens Studio at . Stop it any time with `docker compose -f docker-compose.run.yml down`.

**Want to develop Elliot?** Build from source instead:```bash
# Prerequisites: uv (Python 3.13) and pnpm (Node 22)
git clone https://github.com/EliBarak12/Elliot.git && cd Elliot
make setup
make dev          # boots plugin (:3000) + studio (:5173)
                  # and writes the MCP config for every detected coding agent
                  # the runtime (:3001) starts on demand when you deploy a connector

Then open Studio at , scaffold a connector, lint it, and your agent can use it in the same session.

See it in action

A walkthrough of Elliot Studio — the visual dashboard that observes, runs, and edits everything an agent builds.

> The loop above cycles through every Studio page. For the full-quality screencast, watch the video walkthrough.

Studio in detail:

Tools — verb-first, typed contracts your agents call. Design, validate, and test each one.
Metrics — calls, error rate, latency, and token efficiency across every tool.

Agent Console — a live trace of every agent session: prompts, tool calls, tokens, errors.
Sources — REST APIs, PostgreSQL, MySQL, and files, discovered and managed in one place.

How it works```

  1. Connect your data sources
    REST APIs, PostgreSQL, MySQL, CSV / JSON files — all in one connector

  2. Build tools (no SQL required)
    Define name, description, parameters, filters, and return fields
    Elliot generates safe, parameterised queries
    Or let an agent build the connector for you with the agentic builder

  3. Lint for agent-readiness
    elliot lint my-domain.connector.json

  4. Write and run eval cases
    elliot eval my-domain.eval.yaml — pass/fail plus a token estimate

  5. Deploy and connect agents
    plugin (:3000) serves tools to any MCP client
    runtime (:3001) executes them against live data
    studio observes, runs, and edits everything

  6. (Optional) Ship the connector as a plugin
    elliot export-plugin my-domain.connector.json
    produces an installable Codex + Claude Code plugin folder


On first connect, an agent automatically calls `prompts/get name=getting_started` — a single prompt that teaches it the five principles, the canonical workflow, and the reference resources available.

## Connect your coding agent

`make dev` runs `elliot connect`, which detects every coding agent on your machine and writes its MCP config automatically. To wire a client by hand:

Claude CodeCursor```
/plugin marketplace add EliBarak12/Elliot
/plugin install elliot@elliot

Install the bundled plugin (.cursor-plugin/) from the Cursor marketplace, or add the MCP server by hand:```json
{ "mcpServers": { "elliot": {
"url": "https://api.elliot-cloud.com/b/mcp"
}}}


CodexOpenClaw```
codex plugin marketplace add EliBarak12/Elliot

Then open the plugin directory in Codex and install elliot. Codex reads .agents/plugins/marketplace.json and the manifest at .codex-plugin/plugin.json.```
openclaw plugins install elliot@elliot


OpenClaw also reads the `.claude-plugin/`, `.codex-plugin/`, and `.cursor-plugin/` bundles directly. `elliot connect` writes `~/.openclaw/openclaw.json` with the `streamable-http` transport.

Every install path wires the MCP URL only — Elliot's server still needs to be running, locally or at a hosted endpoint. Skills ship in the repo-root `skills/` directory; Claude Code and Codex auto-discover them, and every other MCP client receives the same guidance as MCP prompts.

### Add Elliot to Claude.ai and Claude Desktop

The table above covers the **Claude Code** plugin. To use Elliot from **Claude.ai** (web) or the **Claude Desktop / mobile** apps, add it as a remote **Connector** — Elliot's hosted endpoint speaks the MCP HTTP transport and runs the full OAuth 2.1 handshake, so there are no keys to paste:

1. In Claude, open **Settings → Connectors**.
2. Click **Add custom connector**.
3. Paste the Elliot MCP URL and confirm:```
   https://api.elliot-cloud.com/b/mcp
   ```
4. Claude registers itself (RFC 7591 dynamic client registration), then sends you to the Elliot consent screen. Sign in, click **Allow**, and Claude returns connected.

Elliot's tools now appear in the connector picker for every chat. The access grant is listed under **Connected agents** in the Elliot dashboard and can be revoked there at any time. Because the connector authenticates each user individually (`scope: per_user`), every teammate authorises with their own identity — no shared secret.

> Self-hosting Elliot? Point the connector at your own deployment's `/b/mcp` URL instead. The OAuth discovery documents are served from the same host, so the only requirement is that it's reachable over HTTPS.

To get Elliot listed in Anthropic's built-in **Connectors directory** (so users can add it without pasting a URL), see `docs/claude-connector-directory.md`.

### Ship a connector as its own plugin

Once you've built a connector, package it as a standalone plugin that installs in Codex *and* Claude Code:```
elliot export-plugin my-domain.connector.json

This scaffolds a my-domain-plugin/ folder with the Codex and Claude Code manifests, marketplaces, an .mcp.json that serves the connector over stdio (elliot-mcp --connector), and a skills/ directory. The MCP server is named after the connector slug, so its tools are mcp____; the generated skills — a usage guide plus one per connector workflow — already reference that prefix. Install it with /plugin marketplace add (Claude Code) or codex plugin marketplace add (Codex).

Project layout

Elliot is a monorepo of four packages:

Package Name Stack Role
packages/core elliot-core Python 3.13 Types, query builder, linter, eval harness, CLI
packages/mcp-plugin elliot-mcp-plugin Python 3.13 · FastMCP MCP endpoint and agentic builder — port 3000
packages/connector-runtime elliot-connector-runtime Python 3.13 · FastAPI Tool execution and session/observation store — port 3001
packages/studio elliot-studio React 19 · Vite Visual dashboard — port 5173 (dev) / 8080 (Docker)

Connector files live in connectors/, starter templates ship with the plugin (browse them via the elliot://templates/ MCP resources), and every environment variable is documented in .env.example.

Documentation

Full documentation lives at elibarak12.github.io/Elliot.

  • Quickstart — get a connector running in minutes
  • Concepts — sources, tools, skills, connectors
  • The five principles — the design rules every connector follows
  • Connector spec — the full .connector.json schema
  • Architecture — how the three services fit together
  • Deployment — Docker images, env vars, hosting

Roadmap

Elliot's goal is to be usable by everyone, not just developers. Progress is tracked in dev/docs/USER_ONBOARDING.md.

Status Milestone
Shipped Run from source — make dev for contributors
Shipped One-command Docker — run with only Docker, no toolchain
Planned Guided first-run — an onboarding wizard inside Studio
Planned Desktop app — a double-click app, no Docker, no terminal
Planned Hosted cloud — a connector registry and a managed runtime, no install at all

Contributing

Contributions are welcome — code, connectors, docs, and bug reports alike.

  • Browse good first issues to get started.
  • New connectors are especially valuable — see the connector request template.
  • Before opening a PR, run the mandatory checks below. All six must pass.bash uv run ruff check . uv run ruff format --check . uv run mypy packages/core/src packages/mcp-plugin/src packages/connector-runtime/src uv run pytest --tb=short pnpm --filter @elliot/studio run typecheck pnpm --filter @elliot/studio test --run

Community and support

Found a bug, have a feature request, or want to propose a connector? Open an issue on the issue tracker — we read every one.

License

Elliot is released under the MIT License.

常见问题

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

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

Elliot 怎么在 Claude、Cursor、Codex 里配置?

它的传输方式未标注,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Elliot 收费吗?

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

Elliot 需要 API Key 吗?

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

Elliot 支持哪些客户端?

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

Elliot 能提供哪些能力?

资料显示能力标签包括 api、database、sql、postgres、rest、observability。具体工具清单以官方文档为准。

Elliot 需要什么运行环境?

运行时为 Cross-platform。

热门专题

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

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